|
3197.c29a6f351f8c45adc2c5.js
|
1 (self["webpackChunk_JUPYTERLAB_CORE_OUTPUT"] = self["webpackChunk_JUPYTERLAB_CORE_OUTPUT"] || []).push([[3197,7061],{
2
3 /***/ 77647:
4 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
5
6 "use strict";
7
8 // EXPORTS
9 __webpack_require__.d(__webpack_exports__, {
10 e: () => (/* reexport */ BaseRegExpVisitor),
11 O: () => (/* reexport */ RegExpParser)
12 });
13
14 ;// CONCATENATED MODULE: ../node_modules/@chevrotain/regexp-to-ast/lib/src/utils.js
15 function cc(char) {
16 return char.charCodeAt(0);
17 }
18 function insertToSet(item, set) {
19 if (Array.isArray(item)) {
20 item.forEach(function (subItem) {
21 set.push(subItem);
22 });
23 }
24 else {
25 set.push(item);
26 }
27 }
28 function addFlag(flagObj, flagKey) {
29 if (flagObj[flagKey] === true) {
30 throw "duplicate flag " + flagKey;
31 }
32 const x = flagObj[flagKey];
33 flagObj[flagKey] = true;
34 }
35 function ASSERT_EXISTS(obj) {
36 // istanbul ignore next
37 if (obj === undefined) {
38 throw Error("Internal Error - Should never get here!");
39 }
40 return true;
41 }
42 // istanbul ignore next
43 function ASSERT_NEVER_REACH_HERE() {
44 throw Error("Internal Error - Should never get here!");
45 }
46 function isCharacter(obj) {
47 return obj["type"] === "Character";
48 }
49 //# sourceMappingURL=utils.js.map
50 ;// CONCATENATED MODULE: ../node_modules/@chevrotain/regexp-to-ast/lib/src/character-classes.js
51
52 const digitsCharCodes = [];
53 for (let i = cc("0"); i <= cc("9"); i++) {
54 digitsCharCodes.push(i);
55 }
56 const wordCharCodes = [cc("_")].concat(digitsCharCodes);
57 for (let i = cc("a"); i <= cc("z"); i++) {
58 wordCharCodes.push(i);
59 }
60 for (let i = cc("A"); i <= cc("Z"); i++) {
61 wordCharCodes.push(i);
62 }
63 // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp#character-classes
64 const whitespaceCodes = [
65 cc(" "),
66 cc("\f"),
67 cc("\n"),
68 cc("\r"),
69 cc("\t"),
70 cc("\v"),
71 cc("\t"),
72 cc("\u00a0"),
73 cc("\u1680"),
74 cc("\u2000"),
75 cc("\u2001"),
76 cc("\u2002"),
77 cc("\u2003"),
78 cc("\u2004"),
79 cc("\u2005"),
80 cc("\u2006"),
81 cc("\u2007"),
82 cc("\u2008"),
83 cc("\u2009"),
84 cc("\u200a"),
85 cc("\u2028"),
86 cc("\u2029"),
87 cc("\u202f"),
88 cc("\u205f"),
89 cc("\u3000"),
90 cc("\ufeff"),
91 ];
92 //# sourceMappingURL=character-classes.js.map
93 ;// CONCATENATED MODULE: ../node_modules/@chevrotain/regexp-to-ast/lib/src/regexp-parser.js
94
95
96 // consts and utilities
97 const hexDigitPattern = /[0-9a-fA-F]/;
98 const decimalPattern = /[0-9]/;
99 const decimalPatternNoZero = /[1-9]/;
100 // https://hackernoon.com/the-madness-of-parsing-real-world-javascript-regexps-d9ee336df983
101 // https://www.ecma-international.org/ecma-262/8.0/index.html#prod-Pattern
102 class RegExpParser {
103 constructor() {
104 this.idx = 0;
105 this.input = "";
106 this.groupIdx = 0;
107 }
108 saveState() {
109 return {
110 idx: this.idx,
111 input: this.input,
112 groupIdx: this.groupIdx,
113 };
114 }
115 restoreState(newState) {
116 this.idx = newState.idx;
117 this.input = newState.input;
118 this.groupIdx = newState.groupIdx;
119 }
120 pattern(input) {
121 // parser state
122 this.idx = 0;
123 this.input = input;
124 this.groupIdx = 0;
125 this.consumeChar("/");
126 const value = this.disjunction();
127 this.consumeChar("/");
128 const flags = {
129 type: "Flags",
130 loc: { begin: this.idx, end: input.length },
131 global: false,
132 ignoreCase: false,
133 multiLine: false,
134 unicode: false,
135 sticky: false,
136 };
137 while (this.isRegExpFlag()) {
138 switch (this.popChar()) {
139 case "g":
140 addFlag(flags, "global");
141 break;
142 case "i":
143 addFlag(flags, "ignoreCase");
144 break;
145 case "m":
146 addFlag(flags, "multiLine");
147 break;
148 case "u":
149 addFlag(flags, "unicode");
150 break;
151 case "y":
152 addFlag(flags, "sticky");
153 break;
154 }
155 }
156 if (this.idx !== this.input.length) {
157 throw Error("Redundant input: " + this.input.substring(this.idx));
158 }
159 return {
160 type: "Pattern",
161 flags: flags,
162 value: value,
163 loc: this.loc(0),
164 };
165 }
166 disjunction() {
167 const alts = [];
168 const begin = this.idx;
169 alts.push(this.alternative());
170 while (this.peekChar() === "|") {
171 this.consumeChar("|");
172 alts.push(this.alternative());
173 }
174 return { type: "Disjunction", value: alts, loc: this.loc(begin) };
175 }
176 alternative() {
177 const terms = [];
178 const begin = this.idx;
179 while (this.isTerm()) {
180 terms.push(this.term());
181 }
182 return { type: "Alternative", value: terms, loc: this.loc(begin) };
183 }
184 term() {
185 if (this.isAssertion()) {
186 return this.assertion();
187 }
188 else {
189 return this.atom();
190 }
191 }
192 assertion() {
193 const begin = this.idx;
194 switch (this.popChar()) {
195 case "^":
196 return {
197 type: "StartAnchor",
198 loc: this.loc(begin),
199 };
200 case "$":
201 return { type: "EndAnchor", loc: this.loc(begin) };
202 // '\b' or '\B'
203 case "\\":
204 switch (this.popChar()) {
205 case "b":
206 return {
207 type: "WordBoundary",
208 loc: this.loc(begin),
209 };
210 case "B":
211 return {
212 type: "NonWordBoundary",
213 loc: this.loc(begin),
214 };
215 }
216 // istanbul ignore next
217 throw Error("Invalid Assertion Escape");
218 // '(?=' or '(?!'
219 case "(":
220 this.consumeChar("?");
221 let type;
222 switch (this.popChar()) {
223 case "=":
224 type = "Lookahead";
225 break;
226 case "!":
227 type = "NegativeLookahead";
228 break;
229 }
230 ASSERT_EXISTS(type);
231 const disjunction = this.disjunction();
232 this.consumeChar(")");
233 return {
234 type: type,
235 value: disjunction,
236 loc: this.loc(begin),
237 };
238 }
239 // istanbul ignore next
240 return ASSERT_NEVER_REACH_HERE();
241 }
242 quantifier(isBacktracking = false) {
243 let range = undefined;
244 const begin = this.idx;
245 switch (this.popChar()) {
246 case "*":
247 range = {
248 atLeast: 0,
249 atMost: Infinity,
250 };
251 break;
252 case "+":
253 range = {
254 atLeast: 1,
255 atMost: Infinity,
256 };
257 break;
258 case "?":
259 range = {
260 atLeast: 0,
261 atMost: 1,
262 };
263 break;
264 case "{":
265 const atLeast = this.integerIncludingZero();
266 switch (this.popChar()) {
267 case "}":
268 range = {
269 atLeast: atLeast,
270 atMost: atLeast,
271 };
272 break;
273 case ",":
274 let atMost;
275 if (this.isDigit()) {
276 atMost = this.integerIncludingZero();
277 range = {
278 atLeast: atLeast,
279 atMost: atMost,
280 };
281 }
282 else {
283 range = {
284 atLeast: atLeast,
285 atMost: Infinity,
286 };
287 }
288 this.consumeChar("}");
289 break;
290 }
291 // throwing exceptions from "ASSERT_EXISTS" during backtracking
292 // causes severe performance degradations
293 if (isBacktracking === true && range === undefined) {
294 return undefined;
295 }
296 ASSERT_EXISTS(range);
297 break;
298 }
299 // throwing exceptions from "ASSERT_EXISTS" during backtracking
300 // causes severe performance degradations
301 if (isBacktracking === true && range === undefined) {
302 return undefined;
303 }
304 // istanbul ignore else
305 if (ASSERT_EXISTS(range)) {
306 if (this.peekChar(0) === "?") {
307 this.consumeChar("?");
308 range.greedy = false;
309 }
310 else {
311 range.greedy = true;
312 }
313 range.type = "Quantifier";
314 range.loc = this.loc(begin);
315 return range;
316 }
317 }
318 atom() {
319 let atom;
320 const begin = this.idx;
321 switch (this.peekChar()) {
322 case ".":
323 atom = this.dotAll();
324 break;
325 case "\\":
326 atom = this.atomEscape();
327 break;
328 case "[":
329 atom = this.characterClass();
330 break;
331 case "(":
332 atom = this.group();
333 break;
334 }
335 if (atom === undefined && this.isPatternCharacter()) {
336 atom = this.patternCharacter();
337 }
338 // istanbul ignore else
339 if (ASSERT_EXISTS(atom)) {
340 atom.loc = this.loc(begin);
341 if (this.isQuantifier()) {
342 atom.quantifier = this.quantifier();
343 }
344 return atom;
345 }
346 // istanbul ignore next
347 return ASSERT_NEVER_REACH_HERE();
348 }
349 dotAll() {
350 this.consumeChar(".");
351 return {
352 type: "Set",
353 complement: true,
354 value: [cc("\n"), cc("\r"), cc("\u2028"), cc("\u2029")],
355 };
356 }
357 atomEscape() {
358 this.consumeChar("\\");
359 switch (this.peekChar()) {
360 case "1":
361 case "2":
362 case "3":
363 case "4":
364 case "5":
365 case "6":
366 case "7":
367 case "8":
368 case "9":
369 return this.decimalEscapeAtom();
370 case "d":
371 case "D":
372 case "s":
373 case "S":
374 case "w":
375 case "W":
376 return this.characterClassEscape();
377 case "f":
378 case "n":
379 case "r":
380 case "t":
381 case "v":
382 return this.controlEscapeAtom();
383 case "c":
384 return this.controlLetterEscapeAtom();
385 case "0":
386 return this.nulCharacterAtom();
387 case "x":
388 return this.hexEscapeSequenceAtom();
389 case "u":
390 return this.regExpUnicodeEscapeSequenceAtom();
391 default:
392 return this.identityEscapeAtom();
393 }
394 }
395 decimalEscapeAtom() {
396 const value = this.positiveInteger();
397 return { type: "GroupBackReference", value: value };
398 }
399 characterClassEscape() {
400 let set;
401 let complement = false;
402 switch (this.popChar()) {
403 case "d":
404 set = digitsCharCodes;
405 break;
406 case "D":
407 set = digitsCharCodes;
408 complement = true;
409 break;
410 case "s":
411 set = whitespaceCodes;
412 break;
413 case "S":
414 set = whitespaceCodes;
415 complement = true;
416 break;
417 case "w":
418 set = wordCharCodes;
419 break;
420 case "W":
421 set = wordCharCodes;
422 complement = true;
423 break;
424 }
425 // istanbul ignore else
426 if (ASSERT_EXISTS(set)) {
427 return { type: "Set", value: set, complement: complement };
428 }
429 // istanbul ignore next
430 return ASSERT_NEVER_REACH_HERE();
431 }
432 controlEscapeAtom() {
433 let escapeCode;
434 switch (this.popChar()) {
435 case "f":
436 escapeCode = cc("\f");
437 break;
438 case "n":
439 escapeCode = cc("\n");
440 break;
441 case "r":
442 escapeCode = cc("\r");
443 break;
444 case "t":
445 escapeCode = cc("\t");
446 break;
447 case "v":
448 escapeCode = cc("\v");
449 break;
450 }
451 // istanbul ignore else
452 if (ASSERT_EXISTS(escapeCode)) {
453 return { type: "Character", value: escapeCode };
454 }
455 // istanbul ignore next
456 return ASSERT_NEVER_REACH_HERE();
457 }
458 controlLetterEscapeAtom() {
459 this.consumeChar("c");
460 const letter = this.popChar();
461 if (/[a-zA-Z]/.test(letter) === false) {
462 throw Error("Invalid ");
463 }
464 const letterCode = letter.toUpperCase().charCodeAt(0) - 64;
465 return { type: "Character", value: letterCode };
466 }
467 nulCharacterAtom() {
468 // TODO implement '[lookahead ∉ DecimalDigit]'
469 // TODO: for the deprecated octal escape sequence
470 this.consumeChar("0");
471 return { type: "Character", value: cc("\0") };
472 }
473 hexEscapeSequenceAtom() {
474 this.consumeChar("x");
475 return this.parseHexDigits(2);
476 }
477 regExpUnicodeEscapeSequenceAtom() {
478 this.consumeChar("u");
479 return this.parseHexDigits(4);
480 }
481 identityEscapeAtom() {
482 // TODO: implement "SourceCharacter but not UnicodeIDContinue"
483 // // http://unicode.org/reports/tr31/#Specific_Character_Adjustments
484 const escapedChar = this.popChar();
485 return { type: "Character", value: cc(escapedChar) };
486 }
487 classPatternCharacterAtom() {
488 switch (this.peekChar()) {
489 // istanbul ignore next
490 case "\n":
491 // istanbul ignore next
492 case "\r":
493 // istanbul ignore next
494 case "\u2028":
495 // istanbul ignore next
496 case "\u2029":
497 // istanbul ignore next
498 case "\\":
499 // istanbul ignore next
500 case "]":
501 throw Error("TBD");
502 default:
503 const nextChar = this.popChar();
504 return { type: "Character", value: cc(nextChar) };
505 }
506 }
507 characterClass() {
508 const set = [];
509 let complement = false;
510 this.consumeChar("[");
511 if (this.peekChar(0) === "^") {
512 this.consumeChar("^");
513 complement = true;
514 }
515 while (this.isClassAtom()) {
516 const from = this.classAtom();
517 const isFromSingleChar = from.type === "Character";
518 if (isCharacter(from) && this.isRangeDash()) {
519 this.consumeChar("-");
520 const to = this.classAtom();
521 const isToSingleChar = to.type === "Character";
522 // a range can only be used when both sides are single characters
523 if (isCharacter(to)) {
524 if (to.value < from.value) {
525 throw Error("Range out of order in character class");
526 }
527 set.push({ from: from.value, to: to.value });
528 }
529 else {
530 // literal dash
531 insertToSet(from.value, set);
532 set.push(cc("-"));
533 insertToSet(to.value, set);
534 }
535 }
536 else {
537 insertToSet(from.value, set);
538 }
539 }
540 this.consumeChar("]");
541 return { type: "Set", complement: complement, value: set };
542 }
543 classAtom() {
544 switch (this.peekChar()) {
545 // istanbul ignore next
546 case "]":
547 // istanbul ignore next
548 case "\n":
549 // istanbul ignore next
550 case "\r":
551 // istanbul ignore next
552 case "\u2028":
553 // istanbul ignore next
554 case "\u2029":
555 throw Error("TBD");
556 case "\\":
557 return this.classEscape();
558 default:
559 return this.classPatternCharacterAtom();
560 }
561 }
562 classEscape() {
563 this.consumeChar("\\");
564 switch (this.peekChar()) {
565 // Matches a backspace.
566 // (Not to be confused with \b word boundary outside characterClass)
567 case "b":
568 this.consumeChar("b");
569 return { type: "Character", value: cc("\u0008") };
570 case "d":
571 case "D":
572 case "s":
573 case "S":
574 case "w":
575 case "W":
576 return this.characterClassEscape();
577 case "f":
578 case "n":
579 case "r":
580 case "t":
581 case "v":
582 return this.controlEscapeAtom();
583 case "c":
584 return this.controlLetterEscapeAtom();
585 case "0":
586 return this.nulCharacterAtom();
587 case "x":
588 return this.hexEscapeSequenceAtom();
589 case "u":
590 return this.regExpUnicodeEscapeSequenceAtom();
591 default:
592 return this.identityEscapeAtom();
593 }
594 }
595 group() {
596 let capturing = true;
597 this.consumeChar("(");
598 switch (this.peekChar(0)) {
599 case "?":
600 this.consumeChar("?");
601 this.consumeChar(":");
602 capturing = false;
603 break;
604 default:
605 this.groupIdx++;
606 break;
607 }
608 const value = this.disjunction();
609 this.consumeChar(")");
610 const groupAst = {
611 type: "Group",
612 capturing: capturing,
613 value: value,
614 };
615 if (capturing) {
616 groupAst["idx"] = this.groupIdx;
617 }
618 return groupAst;
619 }
620 positiveInteger() {
621 let number = this.popChar();
622 // istanbul ignore next - can't ever get here due to previous lookahead checks
623 // still implementing this error checking in case this ever changes.
624 if (decimalPatternNoZero.test(number) === false) {
625 throw Error("Expecting a positive integer");
626 }
627 while (decimalPattern.test(this.peekChar(0))) {
628 number += this.popChar();
629 }
630 return parseInt(number, 10);
631 }
632 integerIncludingZero() {
633 let number = this.popChar();
634 if (decimalPattern.test(number) === false) {
635 throw Error("Expecting an integer");
636 }
637 while (decimalPattern.test(this.peekChar(0))) {
638 number += this.popChar();
639 }
640 return parseInt(number, 10);
641 }
642 patternCharacter() {
643 const nextChar = this.popChar();
644 switch (nextChar) {
645 // istanbul ignore next
646 case "\n":
647 // istanbul ignore next
648 case "\r":
649 // istanbul ignore next
650 case "\u2028":
651 // istanbul ignore next
652 case "\u2029":
653 // istanbul ignore next
654 case "^":
655 // istanbul ignore next
656 case "$":
657 // istanbul ignore next
658 case "\\":
659 // istanbul ignore next
660 case ".":
661 // istanbul ignore next
662 case "*":
663 // istanbul ignore next
664 case "+":
665 // istanbul ignore next
666 case "?":
667 // istanbul ignore next
668 case "(":
669 // istanbul ignore next
670 case ")":
671 // istanbul ignore next
672 case "[":
673 // istanbul ignore next
674 case "|":
675 // istanbul ignore next
676 throw Error("TBD");
677 default:
678 return { type: "Character", value: cc(nextChar) };
679 }
680 }
681 isRegExpFlag() {
682 switch (this.peekChar(0)) {
683 case "g":
684 case "i":
685 case "m":
686 case "u":
687 case "y":
688 return true;
689 default:
690 return false;
691 }
692 }
693 isRangeDash() {
694 return this.peekChar() === "-" && this.isClassAtom(1);
695 }
696 isDigit() {
697 return decimalPattern.test(this.peekChar(0));
698 }
699 isClassAtom(howMuch = 0) {
700 switch (this.peekChar(howMuch)) {
701 case "]":
702 case "\n":
703 case "\r":
704 case "\u2028":
705 case "\u2029":
706 return false;
707 default:
708 return true;
709 }
710 }
711 isTerm() {
712 return this.isAtom() || this.isAssertion();
713 }
714 isAtom() {
715 if (this.isPatternCharacter()) {
716 return true;
717 }
718 switch (this.peekChar(0)) {
719 case ".":
720 case "\\": // atomEscape
721 case "[": // characterClass
722 // TODO: isAtom must be called before isAssertion - disambiguate
723 case "(": // group
724 return true;
725 default:
726 return false;
727 }
728 }
729 isAssertion() {
730 switch (this.peekChar(0)) {
731 case "^":
732 case "$":
733 return true;
734 // '\b' or '\B'
735 case "\\":
736 switch (this.peekChar(1)) {
737 case "b":
738 case "B":
739 return true;
740 default:
741 return false;
742 }
743 // '(?=' or '(?!'
744 case "(":
745 return (this.peekChar(1) === "?" &&
746 (this.peekChar(2) === "=" || this.peekChar(2) === "!"));
747 default:
748 return false;
749 }
750 }
751 isQuantifier() {
752 const prevState = this.saveState();
753 try {
754 return this.quantifier(true) !== undefined;
755 }
756 catch (e) {
757 return false;
758 }
759 finally {
760 this.restoreState(prevState);
761 }
762 }
763 isPatternCharacter() {
764 switch (this.peekChar()) {
765 case "^":
766 case "$":
767 case "\\":
768 case ".":
769 case "*":
770 case "+":
771 case "?":
772 case "(":
773 case ")":
774 case "[":
775 case "|":
776 case "/":
777 case "\n":
778 case "\r":
779 case "\u2028":
780 case "\u2029":
781 return false;
782 default:
783 return true;
784 }
785 }
786 parseHexDigits(howMany) {
787 let hexString = "";
788 for (let i = 0; i < howMany; i++) {
789 const hexChar = this.popChar();
790 if (hexDigitPattern.test(hexChar) === false) {
791 throw Error("Expecting a HexDecimal digits");
792 }
793 hexString += hexChar;
794 }
795 const charCode = parseInt(hexString, 16);
796 return { type: "Character", value: charCode };
797 }
798 peekChar(howMuch = 0) {
799 return this.input[this.idx + howMuch];
800 }
801 popChar() {
802 const nextChar = this.peekChar(0);
803 this.consumeChar(undefined);
804 return nextChar;
805 }
806 consumeChar(char) {
807 if (char !== undefined && this.input[this.idx] !== char) {
808 throw Error("Expected: '" +
809 char +
810 "' but found: '" +
811 this.input[this.idx] +
812 "' at offset: " +
813 this.idx);
814 }
815 if (this.idx >= this.input.length) {
816 throw Error("Unexpected end of input");
817 }
818 this.idx++;
819 }
820 loc(begin) {
821 return { begin: begin, end: this.idx };
822 }
823 }
824 //# sourceMappingURL=regexp-parser.js.map
825 ;// CONCATENATED MODULE: ../node_modules/@chevrotain/regexp-to-ast/lib/src/base-regexp-visitor.js
826 class BaseRegExpVisitor {
827 visitChildren(node) {
828 for (const key in node) {
829 const child = node[key];
830 /* istanbul ignore else */
831 if (node.hasOwnProperty(key)) {
832 if (child.type !== undefined) {
833 this.visit(child);
834 }
835 else if (Array.isArray(child)) {
836 child.forEach((subChild) => {
837 this.visit(subChild);
838 }, this);
839 }
840 }
841 }
842 }
843 visit(node) {
844 switch (node.type) {
845 case "Pattern":
846 this.visitPattern(node);
847 break;
848 case "Flags":
849 this.visitFlags(node);
850 break;
851 case "Disjunction":
852 this.visitDisjunction(node);
853 break;
854 case "Alternative":
855 this.visitAlternative(node);
856 break;
857 case "StartAnchor":
858 this.visitStartAnchor(node);
859 break;
860 case "EndAnchor":
861 this.visitEndAnchor(node);
862 break;
863 case "WordBoundary":
864 this.visitWordBoundary(node);
865 break;
866 case "NonWordBoundary":
867 this.visitNonWordBoundary(node);
868 break;
869 case "Lookahead":
870 this.visitLookahead(node);
871 break;
872 case "NegativeLookahead":
873 this.visitNegativeLookahead(node);
874 break;
875 case "Character":
876 this.visitCharacter(node);
877 break;
878 case "Set":
879 this.visitSet(node);
880 break;
881 case "Group":
882 this.visitGroup(node);
883 break;
884 case "GroupBackReference":
885 this.visitGroupBackReference(node);
886 break;
887 case "Quantifier":
888 this.visitQuantifier(node);
889 break;
890 }
891 this.visitChildren(node);
892 }
893 visitPattern(node) { }
894 visitFlags(node) { }
895 visitDisjunction(node) { }
896 visitAlternative(node) { }
897 // Assertion
898 visitStartAnchor(node) { }
899 visitEndAnchor(node) { }
900 visitWordBoundary(node) { }
901 visitNonWordBoundary(node) { }
902 visitLookahead(node) { }
903 visitNegativeLookahead(node) { }
904 // atoms
905 visitCharacter(node) { }
906 visitSet(node) { }
907 visitGroup(node) { }
908 visitGroupBackReference(node) { }
909 visitQuantifier(node) { }
910 }
911 //# sourceMappingURL=base-regexp-visitor.js.map
912 ;// CONCATENATED MODULE: ../node_modules/@chevrotain/regexp-to-ast/lib/src/api.js
913
914
915 //# sourceMappingURL=api.js.map
916
917 /***/ }),
918
919 /***/ 20078:
920 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
921
922 "use strict";
923 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
924 /* harmony export */ z: () => (/* binding */ createGitGraphServices)
925 /* harmony export */ });
926 /* unused harmony export GitGraphModule */
927 /* harmony import */ var _chunk_7PKI6E2E_mjs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(60960);
928 /* harmony import */ var langium__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(44014);
929 /* harmony import */ var langium__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(81210);
930 /* harmony import */ var langium__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(73001);
931
932
933 // src/language/gitGraph/module.ts
934
935
936 // src/language/gitGraph/tokenBuilder.ts
937 var GitGraphTokenBuilder = class extends _chunk_7PKI6E2E_mjs__WEBPACK_IMPORTED_MODULE_0__/* .AbstractMermaidTokenBuilder */ .T7 {
938 static {
939 (0,_chunk_7PKI6E2E_mjs__WEBPACK_IMPORTED_MODULE_0__/* .__name */ .eW)(this, "GitGraphTokenBuilder");
940 }
941 constructor() {
942 super(["gitGraph"]);
943 }
944 };
945
946 // src/language/gitGraph/module.ts
947 var GitGraphModule = {
948 parser: {
949 TokenBuilder: /* @__PURE__ */ (0,_chunk_7PKI6E2E_mjs__WEBPACK_IMPORTED_MODULE_0__/* .__name */ .eW)(() => new GitGraphTokenBuilder(), "TokenBuilder"),
950 ValueConverter: /* @__PURE__ */ (0,_chunk_7PKI6E2E_mjs__WEBPACK_IMPORTED_MODULE_0__/* .__name */ .eW)(() => new _chunk_7PKI6E2E_mjs__WEBPACK_IMPORTED_MODULE_0__/* .CommonValueConverter */ .nr(), "ValueConverter")
951 }
952 };
953 function createGitGraphServices(context = langium__WEBPACK_IMPORTED_MODULE_1__/* .EmptyFileSystem */ .u) {
954 const shared = (0,langium__WEBPACK_IMPORTED_MODULE_2__/* .inject */ .f3)(
955 (0,langium__WEBPACK_IMPORTED_MODULE_3__/* .createDefaultSharedCoreModule */ .T)(context),
956 _chunk_7PKI6E2E_mjs__WEBPACK_IMPORTED_MODULE_0__/* .MermaidGeneratedSharedModule */ .GS
957 );
958 const GitGraph = (0,langium__WEBPACK_IMPORTED_MODULE_2__/* .inject */ .f3)(
959 (0,langium__WEBPACK_IMPORTED_MODULE_3__/* .createDefaultCoreModule */ .Q)({ shared }),
960 _chunk_7PKI6E2E_mjs__WEBPACK_IMPORTED_MODULE_0__/* .GitGraphGeneratedModule */ .vn,
961 GitGraphModule
962 );
963 shared.ServiceRegistry.register(GitGraph);
964 return { shared, GitGraph };
965 }
966 (0,_chunk_7PKI6E2E_mjs__WEBPACK_IMPORTED_MODULE_0__/* .__name */ .eW)(createGitGraphServices, "createGitGraphServices");
967
968
969
970
971 /***/ }),
972
973 /***/ 51991:
974 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
975
976 "use strict";
977 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
978 /* harmony export */ T: () => (/* binding */ createRadarServices)
979 /* harmony export */ });
980 /* unused harmony export RadarModule */
981 /* harmony import */ var _chunk_7PKI6E2E_mjs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(60960);
982 /* harmony import */ var langium__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(44014);
983 /* harmony import */ var langium__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(81210);
984 /* harmony import */ var langium__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(73001);
985
986
987 // src/language/radar/module.ts
988
989
990 // src/language/radar/tokenBuilder.ts
991 var RadarTokenBuilder = class extends _chunk_7PKI6E2E_mjs__WEBPACK_IMPORTED_MODULE_0__/* .AbstractMermaidTokenBuilder */ .T7 {
992 static {
993 (0,_chunk_7PKI6E2E_mjs__WEBPACK_IMPORTED_MODULE_0__/* .__name */ .eW)(this, "RadarTokenBuilder");
994 }
995 constructor() {
996 super(["radar-beta"]);
997 }
998 };
999
1000 // src/language/radar/module.ts
1001 var RadarModule = {
1002 parser: {
1003 TokenBuilder: /* @__PURE__ */ (0,_chunk_7PKI6E2E_mjs__WEBPACK_IMPORTED_MODULE_0__/* .__name */ .eW)(() => new RadarTokenBuilder(), "TokenBuilder"),
1004 ValueConverter: /* @__PURE__ */ (0,_chunk_7PKI6E2E_mjs__WEBPACK_IMPORTED_MODULE_0__/* .__name */ .eW)(() => new _chunk_7PKI6E2E_mjs__WEBPACK_IMPORTED_MODULE_0__/* .CommonValueConverter */ .nr(), "ValueConverter")
1005 }
1006 };
1007 function createRadarServices(context = langium__WEBPACK_IMPORTED_MODULE_1__/* .EmptyFileSystem */ .u) {
1008 const shared = (0,langium__WEBPACK_IMPORTED_MODULE_2__/* .inject */ .f3)(
1009 (0,langium__WEBPACK_IMPORTED_MODULE_3__/* .createDefaultSharedCoreModule */ .T)(context),
1010 _chunk_7PKI6E2E_mjs__WEBPACK_IMPORTED_MODULE_0__/* .MermaidGeneratedSharedModule */ .GS
1011 );
1012 const Radar = (0,langium__WEBPACK_IMPORTED_MODULE_2__/* .inject */ .f3)(
1013 (0,langium__WEBPACK_IMPORTED_MODULE_3__/* .createDefaultCoreModule */ .Q)({ shared }),
1014 _chunk_7PKI6E2E_mjs__WEBPACK_IMPORTED_MODULE_0__/* .RadarGeneratedModule */ .gB,
1015 RadarModule
1016 );
1017 shared.ServiceRegistry.register(Radar);
1018 return { shared, Radar };
1019 }
1020 (0,_chunk_7PKI6E2E_mjs__WEBPACK_IMPORTED_MODULE_0__/* .__name */ .eW)(createRadarServices, "createRadarServices");
1021
1022
1023
1024
1025 /***/ }),
1026
1027 /***/ 60960:
1028 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
1029
1030 "use strict";
1031
1032 // EXPORTS
1033 __webpack_require__.d(__webpack_exports__, {
1034 T7: () => (/* binding */ AbstractMermaidTokenBuilder),
1035 kb: () => (/* binding */ AbstractMermaidValueConverter),
1036 Qr: () => (/* binding */ ArchitectureGeneratedModule),
1037 nr: () => (/* binding */ CommonValueConverter),
1038 vn: () => (/* binding */ GitGraphGeneratedModule),
1039 F_: () => (/* binding */ InfoGeneratedModule),
1040 GS: () => (/* binding */ MermaidGeneratedSharedModule),
1041 bb: () => (/* binding */ PacketGeneratedModule),
1042 WH: () => (/* binding */ PieGeneratedModule),
1043 gB: () => (/* binding */ RadarGeneratedModule),
1044 eW: () => (/* binding */ __name)
1045 });
1046
1047 // UNUSED EXPORTS: Architecture, Branch, Commit, CommonTokenBuilder, GitGraph, Info, Merge, Packet, PacketBlock, Pie, PieSection, Radar, Statement, isArchitecture, isBranch, isCommit, isCommon, isGitGraph, isInfo, isMerge, isPacket, isPacketBlock, isPie, isPieSection
1048
1049 // EXTERNAL MODULE: ../node_modules/langium/lib/syntax-tree.js
1050 var syntax_tree = __webpack_require__(91303);
1051 // EXTERNAL MODULE: ../node_modules/langium/lib/default-module.js + 42 modules
1052 var default_module = __webpack_require__(73001);
1053 // EXTERNAL MODULE: ../node_modules/langium/lib/dependency-injection.js
1054 var dependency_injection = __webpack_require__(81210);
1055 // EXTERNAL MODULE: ../node_modules/langium/lib/languages/generated/ast.js
1056 var ast = __webpack_require__(34905);
1057 // EXTERNAL MODULE: ../node_modules/langium/lib/workspace/file-system-provider.js
1058 var file_system_provider = __webpack_require__(44014);
1059 // EXTERNAL MODULE: ../node_modules/vscode-uri/lib/esm/index.mjs
1060 var esm = __webpack_require__(37943);
1061 ;// CONCATENATED MODULE: ../node_modules/langium/lib/utils/grammar-loader.js
1062 /******************************************************************************
1063 * Copyright 2023 TypeFox GmbH
1064 * This program and the accompanying materials are made available under the
1065 * terms of the MIT License, which is available in the project root.
1066 ******************************************************************************/
1067
1068
1069
1070
1071
1072 const minimalGrammarModule = {
1073 Grammar: () => undefined,
1074 LanguageMetaData: () => ({
1075 caseInsensitive: false,
1076 fileExtensions: ['.langium'],
1077 languageId: 'langium'
1078 })
1079 };
1080 const minimalSharedGrammarModule = {
1081 AstReflection: () => new ast/* LangiumGrammarAstReflection */.SV()
1082 };
1083 function createMinimalGrammarServices() {
1084 const shared = (0,dependency_injection/* inject */.f3)((0,default_module/* createDefaultSharedCoreModule */.T)(file_system_provider/* EmptyFileSystem */.u), minimalSharedGrammarModule);
1085 const grammar = (0,dependency_injection/* inject */.f3)((0,default_module/* createDefaultCoreModule */.Q)({ shared }), minimalGrammarModule);
1086 shared.ServiceRegistry.register(grammar);
1087 return grammar;
1088 }
1089 /**
1090 * Load a Langium grammar for your language from a JSON string. This is used by several services,
1091 * most notably the parser builder which interprets the grammar to create a parser.
1092 */
1093 function loadGrammarFromJson(json) {
1094 var _a;
1095 const services = createMinimalGrammarServices();
1096 const astNode = services.serializer.JsonSerializer.deserialize(json);
1097 services.shared.workspace.LangiumDocumentFactory.fromModel(astNode, esm/* URI */.o.parse(`memory://${(_a = astNode.name) !== null && _a !== void 0 ? _a : 'grammar'}.langium`));
1098 return astNode;
1099 }
1100 //# sourceMappingURL=grammar-loader.js.map
1101 // EXTERNAL MODULE: ../node_modules/langium/lib/parser/value-converter.js
1102 var value_converter = __webpack_require__(46174);
1103 // EXTERNAL MODULE: ../node_modules/langium/lib/parser/token-builder.js
1104 var token_builder = __webpack_require__(35481);
1105 ;// CONCATENATED MODULE: ../node_modules/@mermaid-js/parser/dist/chunks/mermaid-parser.core/chunk-7PKI6E2E.mjs
1106 var __defProp = Object.defineProperty;
1107 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
1108
1109 // src/language/generated/ast.ts
1110
1111 var Statement = "Statement";
1112 var Architecture = "Architecture";
1113 function isArchitecture(item) {
1114 return reflection.isInstance(item, Architecture);
1115 }
1116 __name(isArchitecture, "isArchitecture");
1117 var Axis = "Axis";
1118 var Branch = "Branch";
1119 function isBranch(item) {
1120 return reflection.isInstance(item, Branch);
1121 }
1122 __name(isBranch, "isBranch");
1123 var Checkout = "Checkout";
1124 var CherryPicking = "CherryPicking";
1125 var Commit = "Commit";
1126 function isCommit(item) {
1127 return reflection.isInstance(item, Commit);
1128 }
1129 __name(isCommit, "isCommit");
1130 var Common = "Common";
1131 function isCommon(item) {
1132 return reflection.isInstance(item, Common);
1133 }
1134 __name(isCommon, "isCommon");
1135 var Curve = "Curve";
1136 var Edge = "Edge";
1137 var Entry = "Entry";
1138 var GitGraph = "GitGraph";
1139 function isGitGraph(item) {
1140 return reflection.isInstance(item, GitGraph);
1141 }
1142 __name(isGitGraph, "isGitGraph");
1143 var Group = "Group";
1144 var Info = "Info";
1145 function isInfo(item) {
1146 return reflection.isInstance(item, Info);
1147 }
1148 __name(isInfo, "isInfo");
1149 var Junction = "Junction";
1150 var Merge = "Merge";
1151 function isMerge(item) {
1152 return reflection.isInstance(item, Merge);
1153 }
1154 __name(isMerge, "isMerge");
1155 var Option = "Option";
1156 var Packet = "Packet";
1157 function isPacket(item) {
1158 return reflection.isInstance(item, Packet);
1159 }
1160 __name(isPacket, "isPacket");
1161 var PacketBlock = "PacketBlock";
1162 function isPacketBlock(item) {
1163 return reflection.isInstance(item, PacketBlock);
1164 }
1165 __name(isPacketBlock, "isPacketBlock");
1166 var Pie = "Pie";
1167 function isPie(item) {
1168 return reflection.isInstance(item, Pie);
1169 }
1170 __name(isPie, "isPie");
1171 var PieSection = "PieSection";
1172 function isPieSection(item) {
1173 return reflection.isInstance(item, PieSection);
1174 }
1175 __name(isPieSection, "isPieSection");
1176 var Radar = "Radar";
1177 var Service = "Service";
1178 var Direction = "Direction";
1179 var MermaidAstReflection = class extends syntax_tree/* AbstractAstReflection */.$v {
1180 static {
1181 __name(this, "MermaidAstReflection");
1182 }
1183 getAllTypes() {
1184 return [Architecture, Axis, Branch, Checkout, CherryPicking, Commit, Common, Curve, Direction, Edge, Entry, GitGraph, Group, Info, Junction, Merge, Option, Packet, PacketBlock, Pie, PieSection, Radar, Service, Statement];
1185 }
1186 computeIsSubtype(subtype, supertype) {
1187 switch (subtype) {
1188 case Branch:
1189 case Checkout:
1190 case CherryPicking:
1191 case Commit:
1192 case Merge: {
1193 return this.isSubtype(Statement, supertype);
1194 }
1195 case Direction: {
1196 return this.isSubtype(GitGraph, supertype);
1197 }
1198 default: {
1199 return false;
1200 }
1201 }
1202 }
1203 getReferenceType(refInfo) {
1204 const referenceId = `${refInfo.container.$type}:${refInfo.property}`;
1205 switch (referenceId) {
1206 case "Entry:axis": {
1207 return Axis;
1208 }
1209 default: {
1210 throw new Error(`${referenceId} is not a valid reference id.`);
1211 }
1212 }
1213 }
1214 getTypeMetaData(type) {
1215 switch (type) {
1216 case Architecture: {
1217 return {
1218 name: Architecture,
1219 properties: [
1220 { name: "accDescr" },
1221 { name: "accTitle" },
1222 { name: "edges", defaultValue: [] },
1223 { name: "groups", defaultValue: [] },
1224 { name: "junctions", defaultValue: [] },
1225 { name: "services", defaultValue: [] },
1226 { name: "title" }
1227 ]
1228 };
1229 }
1230 case Axis: {
1231 return {
1232 name: Axis,
1233 properties: [
1234 { name: "label" },
1235 { name: "name" }
1236 ]
1237 };
1238 }
1239 case Branch: {
1240 return {
1241 name: Branch,
1242 properties: [
1243 { name: "name" },
1244 { name: "order" }
1245 ]
1246 };
1247 }
1248 case Checkout: {
1249 return {
1250 name: Checkout,
1251 properties: [
1252 { name: "branch" }
1253 ]
1254 };
1255 }
1256 case CherryPicking: {
1257 return {
1258 name: CherryPicking,
1259 properties: [
1260 { name: "id" },
1261 { name: "parent" },
1262 { name: "tags", defaultValue: [] }
1263 ]
1264 };
1265 }
1266 case Commit: {
1267 return {
1268 name: Commit,
1269 properties: [
1270 { name: "id" },
1271 { name: "message" },
1272 { name: "tags", defaultValue: [] },
1273 { name: "type" }
1274 ]
1275 };
1276 }
1277 case Common: {
1278 return {
1279 name: Common,
1280 properties: [
1281 { name: "accDescr" },
1282 { name: "accTitle" },
1283 { name: "title" }
1284 ]
1285 };
1286 }
1287 case Curve: {
1288 return {
1289 name: Curve,
1290 properties: [
1291 { name: "entries", defaultValue: [] },
1292 { name: "label" },
1293 { name: "name" }
1294 ]
1295 };
1296 }
1297 case Edge: {
1298 return {
1299 name: Edge,
1300 properties: [
1301 { name: "lhsDir" },
1302 { name: "lhsGroup", defaultValue: false },
1303 { name: "lhsId" },
1304 { name: "lhsInto", defaultValue: false },
1305 { name: "rhsDir" },
1306 { name: "rhsGroup", defaultValue: false },
1307 { name: "rhsId" },
1308 { name: "rhsInto", defaultValue: false },
1309 { name: "title" }
1310 ]
1311 };
1312 }
1313 case Entry: {
1314 return {
1315 name: Entry,
1316 properties: [
1317 { name: "axis" },
1318 { name: "value" }
1319 ]
1320 };
1321 }
1322 case GitGraph: {
1323 return {
1324 name: GitGraph,
1325 properties: [
1326 { name: "accDescr" },
1327 { name: "accTitle" },
1328 { name: "statements", defaultValue: [] },
1329 { name: "title" }
1330 ]
1331 };
1332 }
1333 case Group: {
1334 return {
1335 name: Group,
1336 properties: [
1337 { name: "icon" },
1338 { name: "id" },
1339 { name: "in" },
1340 { name: "title" }
1341 ]
1342 };
1343 }
1344 case Info: {
1345 return {
1346 name: Info,
1347 properties: [
1348 { name: "accDescr" },
1349 { name: "accTitle" },
1350 { name: "title" }
1351 ]
1352 };
1353 }
1354 case Junction: {
1355 return {
1356 name: Junction,
1357 properties: [
1358 { name: "id" },
1359 { name: "in" }
1360 ]
1361 };
1362 }
1363 case Merge: {
1364 return {
1365 name: Merge,
1366 properties: [
1367 { name: "branch" },
1368 { name: "id" },
1369 { name: "tags", defaultValue: [] },
1370 { name: "type" }
1371 ]
1372 };
1373 }
1374 case Option: {
1375 return {
1376 name: Option,
1377 properties: [
1378 { name: "name" },
1379 { name: "value", defaultValue: false }
1380 ]
1381 };
1382 }
1383 case Packet: {
1384 return {
1385 name: Packet,
1386 properties: [
1387 { name: "accDescr" },
1388 { name: "accTitle" },
1389 { name: "blocks", defaultValue: [] },
1390 { name: "title" }
1391 ]
1392 };
1393 }
1394 case PacketBlock: {
1395 return {
1396 name: PacketBlock,
1397 properties: [
1398 { name: "end" },
1399 { name: "label" },
1400 { name: "start" }
1401 ]
1402 };
1403 }
1404 case Pie: {
1405 return {
1406 name: Pie,
1407 properties: [
1408 { name: "accDescr" },
1409 { name: "accTitle" },
1410 { name: "sections", defaultValue: [] },
1411 { name: "showData", defaultValue: false },
1412 { name: "title" }
1413 ]
1414 };
1415 }
1416 case PieSection: {
1417 return {
1418 name: PieSection,
1419 properties: [
1420 { name: "label" },
1421 { name: "value" }
1422 ]
1423 };
1424 }
1425 case Radar: {
1426 return {
1427 name: Radar,
1428 properties: [
1429 { name: "accDescr" },
1430 { name: "accTitle" },
1431 { name: "axes", defaultValue: [] },
1432 { name: "curves", defaultValue: [] },
1433 { name: "options", defaultValue: [] },
1434 { name: "title" }
1435 ]
1436 };
1437 }
1438 case Service: {
1439 return {
1440 name: Service,
1441 properties: [
1442 { name: "icon" },
1443 { name: "iconText" },
1444 { name: "id" },
1445 { name: "in" },
1446 { name: "title" }
1447 ]
1448 };
1449 }
1450 case Direction: {
1451 return {
1452 name: Direction,
1453 properties: [
1454 { name: "accDescr" },
1455 { name: "accTitle" },
1456 { name: "dir" },
1457 { name: "statements", defaultValue: [] },
1458 { name: "title" }
1459 ]
1460 };
1461 }
1462 default: {
1463 return {
1464 name: type,
1465 properties: []
1466 };
1467 }
1468 }
1469 }
1470 };
1471 var reflection = new MermaidAstReflection();
1472
1473 // src/language/generated/grammar.ts
1474
1475 var loadedInfoGrammar;
1476 var InfoGrammar = /* @__PURE__ */ __name(() => loadedInfoGrammar ?? (loadedInfoGrammar = loadGrammarFromJson('{"$type":"Grammar","isDeclared":true,"name":"Info","imports":[],"rules":[{"$type":"ParserRule","entry":true,"name":"Info","definition":{"$type":"Group","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@3"},"arguments":[],"cardinality":"*"},{"$type":"Keyword","value":"info"},{"$type":"RuleCall","rule":{"$ref":"#/rules@3"},"arguments":[],"cardinality":"*"},{"$type":"Group","elements":[{"$type":"Keyword","value":"showInfo"},{"$type":"RuleCall","rule":{"$ref":"#/rules@3"},"arguments":[],"cardinality":"*"}],"cardinality":"?"},{"$type":"RuleCall","rule":{"$ref":"#/rules@1"},"arguments":[],"cardinality":"?"}]},"definesHiddenTokens":false,"fragment":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"ParserRule","fragment":true,"name":"TitleAndAccessibilities","definition":{"$type":"Group","elements":[{"$type":"Alternatives","elements":[{"$type":"Assignment","feature":"accDescr","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@4"},"arguments":[]}},{"$type":"Assignment","feature":"accTitle","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@5"},"arguments":[]}},{"$type":"Assignment","feature":"title","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@6"},"arguments":[]}}]},{"$type":"RuleCall","rule":{"$ref":"#/rules@2"},"arguments":[]}],"cardinality":"+"},"definesHiddenTokens":false,"entry":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"ParserRule","fragment":true,"name":"EOL","dataType":"string","definition":{"$type":"Alternatives","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@3"},"arguments":[],"cardinality":"+"},{"$type":"EndOfFile"}]},"definesHiddenTokens":false,"entry":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"TerminalRule","name":"NEWLINE","definition":{"$type":"RegexToken","regex":"/\\\\r?\\\\n/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ACC_DESCR","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*accDescr(?:[\\\\t ]*:([^\\\\n\\\\r]*?(?=%%)|[^\\\\n\\\\r]*)|\\\\s*{([^}]*)})/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ACC_TITLE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*accTitle[\\\\t ]*:(?:[^\\\\n\\\\r]*?(?=%%)|[^\\\\n\\\\r]*)/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"TITLE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*title(?:[\\\\t ][^\\\\n\\\\r]*?(?=%%)|[\\\\t ][^\\\\n\\\\r]*|)/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","hidden":true,"name":"WHITESPACE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]+/"},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"YAML","definition":{"$type":"RegexToken","regex":"/---[\\\\t ]*\\\\r?\\\\n(?:[\\\\S\\\\s]*?\\\\r?\\\\n)?---(?:\\\\r?\\\\n|(?!\\\\S))/"},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"DIRECTIVE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*%%{[\\\\S\\\\s]*?}%%(?:\\\\r?\\\\n|(?!\\\\S))/"},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"SINGLE_LINE_COMMENT","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*%%[^\\\\n\\\\r]*/"},"fragment":false}],"definesHiddenTokens":false,"hiddenTokens":[],"interfaces":[{"$type":"Interface","name":"Common","attributes":[{"$type":"TypeAttribute","name":"accDescr","isOptional":true,"type":{"$type":"SimpleType","primitiveType":"string"}},{"$type":"TypeAttribute","name":"accTitle","isOptional":true,"type":{"$type":"SimpleType","primitiveType":"string"}},{"$type":"TypeAttribute","name":"title","isOptional":true,"type":{"$type":"SimpleType","primitiveType":"string"}}],"superTypes":[]}],"types":[],"usedGrammars":[]}')), "InfoGrammar");
1477 var loadedPacketGrammar;
1478 var PacketGrammar = /* @__PURE__ */ __name(() => loadedPacketGrammar ?? (loadedPacketGrammar = loadGrammarFromJson(`{"$type":"Grammar","isDeclared":true,"name":"Packet","imports":[],"rules":[{"$type":"ParserRule","entry":true,"name":"Packet","definition":{"$type":"Group","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@6"},"arguments":[],"cardinality":"*"},{"$type":"Keyword","value":"packet-beta"},{"$type":"Alternatives","elements":[{"$type":"Group","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@6"},"arguments":[],"cardinality":"*"},{"$type":"RuleCall","rule":{"$ref":"#/rules@4"},"arguments":[]},{"$type":"Assignment","feature":"blocks","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@1"},"arguments":[]},"cardinality":"*"}]},{"$type":"Group","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@6"},"arguments":[],"cardinality":"+"},{"$type":"Assignment","feature":"blocks","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@1"},"arguments":[]},"cardinality":"+"}]},{"$type":"RuleCall","rule":{"$ref":"#/rules@6"},"arguments":[],"cardinality":"*"}]}]},"definesHiddenTokens":false,"fragment":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"ParserRule","name":"PacketBlock","definition":{"$type":"Group","elements":[{"$type":"Assignment","feature":"start","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@2"},"arguments":[]}},{"$type":"Group","elements":[{"$type":"Keyword","value":"-"},{"$type":"Assignment","feature":"end","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@2"},"arguments":[]}}],"cardinality":"?"},{"$type":"Keyword","value":":"},{"$type":"Assignment","feature":"label","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@3"},"arguments":[]}},{"$type":"RuleCall","rule":{"$ref":"#/rules@5"},"arguments":[]}]},"definesHiddenTokens":false,"entry":false,"fragment":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"TerminalRule","name":"INT","type":{"$type":"ReturnType","name":"number"},"definition":{"$type":"RegexToken","regex":"/0|[1-9][0-9]*/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"STRING","definition":{"$type":"RegexToken","regex":"/\\"[^\\"]*\\"|'[^']*'/"},"fragment":false,"hidden":false},{"$type":"ParserRule","fragment":true,"name":"TitleAndAccessibilities","definition":{"$type":"Group","elements":[{"$type":"Alternatives","elements":[{"$type":"Assignment","feature":"accDescr","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@7"},"arguments":[]}},{"$type":"Assignment","feature":"accTitle","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@8"},"arguments":[]}},{"$type":"Assignment","feature":"title","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@9"},"arguments":[]}}]},{"$type":"RuleCall","rule":{"$ref":"#/rules@5"},"arguments":[]}],"cardinality":"+"},"definesHiddenTokens":false,"entry":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"ParserRule","fragment":true,"name":"EOL","dataType":"string","definition":{"$type":"Alternatives","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@6"},"arguments":[],"cardinality":"+"},{"$type":"EndOfFile"}]},"definesHiddenTokens":false,"entry":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"TerminalRule","name":"NEWLINE","definition":{"$type":"RegexToken","regex":"/\\\\r?\\\\n/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ACC_DESCR","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*accDescr(?:[\\\\t ]*:([^\\\\n\\\\r]*?(?=%%)|[^\\\\n\\\\r]*)|\\\\s*{([^}]*)})/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ACC_TITLE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*accTitle[\\\\t ]*:(?:[^\\\\n\\\\r]*?(?=%%)|[^\\\\n\\\\r]*)/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"TITLE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*title(?:[\\\\t ][^\\\\n\\\\r]*?(?=%%)|[\\\\t ][^\\\\n\\\\r]*|)/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","hidden":true,"name":"WHITESPACE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]+/"},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"YAML","definition":{"$type":"RegexToken","regex":"/---[\\\\t ]*\\\\r?\\\\n(?:[\\\\S\\\\s]*?\\\\r?\\\\n)?---(?:\\\\r?\\\\n|(?!\\\\S))/"},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"DIRECTIVE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*%%{[\\\\S\\\\s]*?}%%(?:\\\\r?\\\\n|(?!\\\\S))/"},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"SINGLE_LINE_COMMENT","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*%%[^\\\\n\\\\r]*/"},"fragment":false}],"definesHiddenTokens":false,"hiddenTokens":[],"interfaces":[{"$type":"Interface","name":"Common","attributes":[{"$type":"TypeAttribute","name":"accDescr","isOptional":true,"type":{"$type":"SimpleType","primitiveType":"string"}},{"$type":"TypeAttribute","name":"accTitle","isOptional":true,"type":{"$type":"SimpleType","primitiveType":"string"}},{"$type":"TypeAttribute","name":"title","isOptional":true,"type":{"$type":"SimpleType","primitiveType":"string"}}],"superTypes":[]}],"types":[],"usedGrammars":[]}`)), "PacketGrammar");
1479 var loadedPieGrammar;
1480 var PieGrammar = /* @__PURE__ */ __name(() => loadedPieGrammar ?? (loadedPieGrammar = loadGrammarFromJson('{"$type":"Grammar","isDeclared":true,"name":"Pie","imports":[],"rules":[{"$type":"ParserRule","entry":true,"name":"Pie","definition":{"$type":"Group","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@6"},"arguments":[],"cardinality":"*"},{"$type":"Keyword","value":"pie"},{"$type":"Assignment","feature":"showData","operator":"?=","terminal":{"$type":"Keyword","value":"showData"},"cardinality":"?"},{"$type":"Alternatives","elements":[{"$type":"Group","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@6"},"arguments":[],"cardinality":"*"},{"$type":"RuleCall","rule":{"$ref":"#/rules@4"},"arguments":[]},{"$type":"Assignment","feature":"sections","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@1"},"arguments":[]},"cardinality":"*"}]},{"$type":"Group","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@6"},"arguments":[],"cardinality":"+"},{"$type":"Assignment","feature":"sections","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@1"},"arguments":[]},"cardinality":"+"}]},{"$type":"RuleCall","rule":{"$ref":"#/rules@6"},"arguments":[],"cardinality":"*"}]}]},"definesHiddenTokens":false,"fragment":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"ParserRule","name":"PieSection","definition":{"$type":"Group","elements":[{"$type":"Assignment","feature":"label","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@2"},"arguments":[]}},{"$type":"Keyword","value":":"},{"$type":"Assignment","feature":"value","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@3"},"arguments":[]}},{"$type":"RuleCall","rule":{"$ref":"#/rules@5"},"arguments":[]}]},"definesHiddenTokens":false,"entry":false,"fragment":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"TerminalRule","name":"PIE_SECTION_LABEL","definition":{"$type":"RegexToken","regex":"/\\"[^\\"]+\\"/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"PIE_SECTION_VALUE","type":{"$type":"ReturnType","name":"number"},"definition":{"$type":"RegexToken","regex":"/(0|[1-9][0-9]*)(\\\\.[0-9]+)?/"},"fragment":false,"hidden":false},{"$type":"ParserRule","fragment":true,"name":"TitleAndAccessibilities","definition":{"$type":"Group","elements":[{"$type":"Alternatives","elements":[{"$type":"Assignment","feature":"accDescr","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@7"},"arguments":[]}},{"$type":"Assignment","feature":"accTitle","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@8"},"arguments":[]}},{"$type":"Assignment","feature":"title","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@9"},"arguments":[]}}]},{"$type":"RuleCall","rule":{"$ref":"#/rules@5"},"arguments":[]}],"cardinality":"+"},"definesHiddenTokens":false,"entry":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"ParserRule","fragment":true,"name":"EOL","dataType":"string","definition":{"$type":"Alternatives","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@6"},"arguments":[],"cardinality":"+"},{"$type":"EndOfFile"}]},"definesHiddenTokens":false,"entry":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"TerminalRule","name":"NEWLINE","definition":{"$type":"RegexToken","regex":"/\\\\r?\\\\n/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ACC_DESCR","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*accDescr(?:[\\\\t ]*:([^\\\\n\\\\r]*?(?=%%)|[^\\\\n\\\\r]*)|\\\\s*{([^}]*)})/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ACC_TITLE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*accTitle[\\\\t ]*:(?:[^\\\\n\\\\r]*?(?=%%)|[^\\\\n\\\\r]*)/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"TITLE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*title(?:[\\\\t ][^\\\\n\\\\r]*?(?=%%)|[\\\\t ][^\\\\n\\\\r]*|)/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","hidden":true,"name":"WHITESPACE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]+/"},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"YAML","definition":{"$type":"RegexToken","regex":"/---[\\\\t ]*\\\\r?\\\\n(?:[\\\\S\\\\s]*?\\\\r?\\\\n)?---(?:\\\\r?\\\\n|(?!\\\\S))/"},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"DIRECTIVE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*%%{[\\\\S\\\\s]*?}%%(?:\\\\r?\\\\n|(?!\\\\S))/"},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"SINGLE_LINE_COMMENT","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*%%[^\\\\n\\\\r]*/"},"fragment":false}],"definesHiddenTokens":false,"hiddenTokens":[],"interfaces":[{"$type":"Interface","name":"Common","attributes":[{"$type":"TypeAttribute","name":"accDescr","isOptional":true,"type":{"$type":"SimpleType","primitiveType":"string"}},{"$type":"TypeAttribute","name":"accTitle","isOptional":true,"type":{"$type":"SimpleType","primitiveType":"string"}},{"$type":"TypeAttribute","name":"title","isOptional":true,"type":{"$type":"SimpleType","primitiveType":"string"}}],"superTypes":[]}],"types":[],"usedGrammars":[]}')), "PieGrammar");
1481 var loadedArchitectureGrammar;
1482 var ArchitectureGrammar = /* @__PURE__ */ __name(() => loadedArchitectureGrammar ?? (loadedArchitectureGrammar = loadGrammarFromJson('{"$type":"Grammar","isDeclared":true,"name":"Architecture","imports":[],"rules":[{"$type":"ParserRule","entry":true,"name":"Architecture","definition":{"$type":"Group","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@18"},"arguments":[],"cardinality":"*"},{"$type":"Keyword","value":"architecture-beta"},{"$type":"Alternatives","elements":[{"$type":"Group","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@18"},"arguments":[],"cardinality":"*"},{"$type":"RuleCall","rule":{"$ref":"#/rules@16"},"arguments":[]}]},{"$type":"Group","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@18"},"arguments":[],"cardinality":"*"},{"$type":"RuleCall","rule":{"$ref":"#/rules@1"},"arguments":[],"cardinality":"*"}]},{"$type":"RuleCall","rule":{"$ref":"#/rules@18"},"arguments":[],"cardinality":"*"}]}]},"definesHiddenTokens":false,"fragment":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"ParserRule","fragment":true,"name":"Statement","definition":{"$type":"Alternatives","elements":[{"$type":"Assignment","feature":"groups","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@5"},"arguments":[]}},{"$type":"Assignment","feature":"services","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@6"},"arguments":[]}},{"$type":"Assignment","feature":"junctions","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@7"},"arguments":[]}},{"$type":"Assignment","feature":"edges","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@8"},"arguments":[]}}]},"definesHiddenTokens":false,"entry":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"ParserRule","fragment":true,"name":"LeftPort","definition":{"$type":"Group","elements":[{"$type":"Keyword","value":":"},{"$type":"Assignment","feature":"lhsDir","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@9"},"arguments":[]}}]},"definesHiddenTokens":false,"entry":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"ParserRule","fragment":true,"name":"RightPort","definition":{"$type":"Group","elements":[{"$type":"Assignment","feature":"rhsDir","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@9"},"arguments":[]}},{"$type":"Keyword","value":":"}]},"definesHiddenTokens":false,"entry":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"ParserRule","fragment":true,"name":"Arrow","definition":{"$type":"Group","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@2"},"arguments":[]},{"$type":"Assignment","feature":"lhsInto","operator":"?=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@15"},"arguments":[]},"cardinality":"?"},{"$type":"Alternatives","elements":[{"$type":"Keyword","value":"--"},{"$type":"Group","elements":[{"$type":"Keyword","value":"-"},{"$type":"Assignment","feature":"title","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@13"},"arguments":[]}},{"$type":"Keyword","value":"-"}]}]},{"$type":"Assignment","feature":"rhsInto","operator":"?=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@15"},"arguments":[]},"cardinality":"?"},{"$type":"RuleCall","rule":{"$ref":"#/rules@3"},"arguments":[]}]},"definesHiddenTokens":false,"entry":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"ParserRule","name":"Group","definition":{"$type":"Group","elements":[{"$type":"Keyword","value":"group"},{"$type":"Assignment","feature":"id","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@10"},"arguments":[]}},{"$type":"Assignment","feature":"icon","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@12"},"arguments":[]},"cardinality":"?"},{"$type":"Assignment","feature":"title","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@13"},"arguments":[]},"cardinality":"?"},{"$type":"Group","elements":[{"$type":"Keyword","value":"in"},{"$type":"Assignment","feature":"in","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@10"},"arguments":[]}}],"cardinality":"?"},{"$type":"RuleCall","rule":{"$ref":"#/rules@17"},"arguments":[]}]},"definesHiddenTokens":false,"entry":false,"fragment":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"ParserRule","name":"Service","definition":{"$type":"Group","elements":[{"$type":"Keyword","value":"service"},{"$type":"Assignment","feature":"id","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@10"},"arguments":[]}},{"$type":"Alternatives","elements":[{"$type":"Assignment","feature":"iconText","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@11"},"arguments":[]}},{"$type":"Assignment","feature":"icon","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@12"},"arguments":[]}}],"cardinality":"?"},{"$type":"Assignment","feature":"title","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@13"},"arguments":[]},"cardinality":"?"},{"$type":"Group","elements":[{"$type":"Keyword","value":"in"},{"$type":"Assignment","feature":"in","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@10"},"arguments":[]}}],"cardinality":"?"},{"$type":"RuleCall","rule":{"$ref":"#/rules@17"},"arguments":[]}]},"definesHiddenTokens":false,"entry":false,"fragment":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"ParserRule","name":"Junction","definition":{"$type":"Group","elements":[{"$type":"Keyword","value":"junction"},{"$type":"Assignment","feature":"id","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@10"},"arguments":[]}},{"$type":"Group","elements":[{"$type":"Keyword","value":"in"},{"$type":"Assignment","feature":"in","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@10"},"arguments":[]}}],"cardinality":"?"},{"$type":"RuleCall","rule":{"$ref":"#/rules@17"},"arguments":[]}]},"definesHiddenTokens":false,"entry":false,"fragment":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"ParserRule","name":"Edge","definition":{"$type":"Group","elements":[{"$type":"Assignment","feature":"lhsId","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@10"},"arguments":[]}},{"$type":"Assignment","feature":"lhsGroup","operator":"?=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@14"},"arguments":[]},"cardinality":"?"},{"$type":"RuleCall","rule":{"$ref":"#/rules@4"},"arguments":[]},{"$type":"Assignment","feature":"rhsId","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@10"},"arguments":[]}},{"$type":"Assignment","feature":"rhsGroup","operator":"?=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@14"},"arguments":[]},"cardinality":"?"},{"$type":"RuleCall","rule":{"$ref":"#/rules@17"},"arguments":[]}]},"definesHiddenTokens":false,"entry":false,"fragment":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"TerminalRule","name":"ARROW_DIRECTION","definition":{"$type":"TerminalAlternatives","elements":[{"$type":"TerminalAlternatives","elements":[{"$type":"TerminalAlternatives","elements":[{"$type":"CharacterRange","left":{"$type":"Keyword","value":"L"}},{"$type":"CharacterRange","left":{"$type":"Keyword","value":"R"}}]},{"$type":"CharacterRange","left":{"$type":"Keyword","value":"T"}}]},{"$type":"CharacterRange","left":{"$type":"Keyword","value":"B"}}]},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ARCH_ID","definition":{"$type":"RegexToken","regex":"/[\\\\w]+/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ARCH_TEXT_ICON","definition":{"$type":"RegexToken","regex":"/\\\\(\\"[^\\"]+\\"\\\\)/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ARCH_ICON","definition":{"$type":"RegexToken","regex":"/\\\\([\\\\w-:]+\\\\)/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ARCH_TITLE","definition":{"$type":"RegexToken","regex":"/\\\\[[\\\\w ]+\\\\]/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ARROW_GROUP","definition":{"$type":"RegexToken","regex":"/\\\\{group\\\\}/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ARROW_INTO","definition":{"$type":"RegexToken","regex":"/<|>/"},"fragment":false,"hidden":false},{"$type":"ParserRule","fragment":true,"name":"TitleAndAccessibilities","definition":{"$type":"Group","elements":[{"$type":"Alternatives","elements":[{"$type":"Assignment","feature":"accDescr","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@19"},"arguments":[]}},{"$type":"Assignment","feature":"accTitle","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@20"},"arguments":[]}},{"$type":"Assignment","feature":"title","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@21"},"arguments":[]}}]},{"$type":"RuleCall","rule":{"$ref":"#/rules@17"},"arguments":[]}],"cardinality":"+"},"definesHiddenTokens":false,"entry":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"ParserRule","fragment":true,"name":"EOL","dataType":"string","definition":{"$type":"Alternatives","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@18"},"arguments":[],"cardinality":"+"},{"$type":"EndOfFile"}]},"definesHiddenTokens":false,"entry":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"TerminalRule","name":"NEWLINE","definition":{"$type":"RegexToken","regex":"/\\\\r?\\\\n/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ACC_DESCR","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*accDescr(?:[\\\\t ]*:([^\\\\n\\\\r]*?(?=%%)|[^\\\\n\\\\r]*)|\\\\s*{([^}]*)})/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ACC_TITLE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*accTitle[\\\\t ]*:(?:[^\\\\n\\\\r]*?(?=%%)|[^\\\\n\\\\r]*)/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"TITLE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*title(?:[\\\\t ][^\\\\n\\\\r]*?(?=%%)|[\\\\t ][^\\\\n\\\\r]*|)/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","hidden":true,"name":"WHITESPACE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]+/"},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"YAML","definition":{"$type":"RegexToken","regex":"/---[\\\\t ]*\\\\r?\\\\n(?:[\\\\S\\\\s]*?\\\\r?\\\\n)?---(?:\\\\r?\\\\n|(?!\\\\S))/"},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"DIRECTIVE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*%%{[\\\\S\\\\s]*?}%%(?:\\\\r?\\\\n|(?!\\\\S))/"},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"SINGLE_LINE_COMMENT","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*%%[^\\\\n\\\\r]*/"},"fragment":false}],"definesHiddenTokens":false,"hiddenTokens":[],"interfaces":[{"$type":"Interface","name":"Common","attributes":[{"$type":"TypeAttribute","name":"accDescr","isOptional":true,"type":{"$type":"SimpleType","primitiveType":"string"}},{"$type":"TypeAttribute","name":"accTitle","isOptional":true,"type":{"$type":"SimpleType","primitiveType":"string"}},{"$type":"TypeAttribute","name":"title","isOptional":true,"type":{"$type":"SimpleType","primitiveType":"string"}}],"superTypes":[]}],"types":[],"usedGrammars":[]}')), "ArchitectureGrammar");
1483 var loadedGitGraphGrammar;
1484 var GitGraphGrammar = /* @__PURE__ */ __name(() => loadedGitGraphGrammar ?? (loadedGitGraphGrammar = loadGrammarFromJson(`{"$type":"Grammar","isDeclared":true,"name":"GitGraph","interfaces":[{"$type":"Interface","name":"Common","attributes":[{"$type":"TypeAttribute","name":"accDescr","isOptional":true,"type":{"$type":"SimpleType","primitiveType":"string"}},{"$type":"TypeAttribute","name":"accTitle","isOptional":true,"type":{"$type":"SimpleType","primitiveType":"string"}},{"$type":"TypeAttribute","name":"title","isOptional":true,"type":{"$type":"SimpleType","primitiveType":"string"}}],"superTypes":[]}],"rules":[{"$type":"ParserRule","fragment":true,"name":"TitleAndAccessibilities","definition":{"$type":"Group","elements":[{"$type":"Alternatives","elements":[{"$type":"Assignment","feature":"accDescr","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@3"},"arguments":[]}},{"$type":"Assignment","feature":"accTitle","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@4"},"arguments":[]}},{"$type":"Assignment","feature":"title","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@5"},"arguments":[]}}]},{"$type":"RuleCall","rule":{"$ref":"#/rules@1"},"arguments":[]}],"cardinality":"+"},"definesHiddenTokens":false,"entry":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"ParserRule","fragment":true,"name":"EOL","dataType":"string","definition":{"$type":"Alternatives","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@2"},"arguments":[],"cardinality":"+"},{"$type":"EndOfFile"}]},"definesHiddenTokens":false,"entry":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"TerminalRule","name":"NEWLINE","definition":{"$type":"RegexToken","regex":"/\\\\r?\\\\n/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ACC_DESCR","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*accDescr(?:[\\\\t ]*:([^\\\\n\\\\r]*?(?=%%)|[^\\\\n\\\\r]*)|\\\\s*{([^}]*)})/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ACC_TITLE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*accTitle[\\\\t ]*:(?:[^\\\\n\\\\r]*?(?=%%)|[^\\\\n\\\\r]*)/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"TITLE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*title(?:[\\\\t ][^\\\\n\\\\r]*?(?=%%)|[\\\\t ][^\\\\n\\\\r]*|)/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","hidden":true,"name":"WHITESPACE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]+/"},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"YAML","definition":{"$type":"RegexToken","regex":"/---[\\\\t ]*\\\\r?\\\\n(?:[\\\\S\\\\s]*?\\\\r?\\\\n)?---(?:\\\\r?\\\\n|(?!\\\\S))/"},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"DIRECTIVE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*%%{[\\\\S\\\\s]*?}%%(?:\\\\r?\\\\n|(?!\\\\S))/"},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"SINGLE_LINE_COMMENT","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*%%[^\\\\n\\\\r]*/"},"fragment":false},{"$type":"ParserRule","entry":true,"name":"GitGraph","definition":{"$type":"Group","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@2"},"arguments":[],"cardinality":"*"},{"$type":"Alternatives","elements":[{"$type":"Keyword","value":"gitGraph"},{"$type":"Group","elements":[{"$type":"Keyword","value":"gitGraph"},{"$type":"Keyword","value":":"}]},{"$type":"Keyword","value":"gitGraph:"},{"$type":"Group","elements":[{"$type":"Keyword","value":"gitGraph"},{"$type":"RuleCall","rule":{"$ref":"#/rules@12"},"arguments":[]},{"$type":"Keyword","value":":"}]}]},{"$type":"RuleCall","rule":{"$ref":"#/rules@2"},"arguments":[],"cardinality":"*"},{"$type":"Group","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@2"},"arguments":[],"cardinality":"*"},{"$type":"Alternatives","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@0"},"arguments":[]},{"$type":"Assignment","feature":"statements","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@11"},"arguments":[]}},{"$type":"RuleCall","rule":{"$ref":"#/rules@2"},"arguments":[]}],"cardinality":"*"}]}]},"definesHiddenTokens":false,"fragment":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"ParserRule","name":"Statement","definition":{"$type":"Alternatives","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@13"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@14"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@15"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@16"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@17"},"arguments":[]}]},"definesHiddenTokens":false,"entry":false,"fragment":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"ParserRule","name":"Direction","definition":{"$type":"Assignment","feature":"dir","operator":"=","terminal":{"$type":"Alternatives","elements":[{"$type":"Keyword","value":"LR"},{"$type":"Keyword","value":"TB"},{"$type":"Keyword","value":"BT"}]}},"definesHiddenTokens":false,"entry":false,"fragment":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"ParserRule","name":"Commit","definition":{"$type":"Group","elements":[{"$type":"Keyword","value":"commit"},{"$type":"Alternatives","elements":[{"$type":"Group","elements":[{"$type":"Keyword","value":"id:"},{"$type":"Assignment","feature":"id","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@20"},"arguments":[]}}]},{"$type":"Group","elements":[{"$type":"Keyword","value":"msg:","cardinality":"?"},{"$type":"Assignment","feature":"message","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@20"},"arguments":[]}}]},{"$type":"Group","elements":[{"$type":"Keyword","value":"tag:"},{"$type":"Assignment","feature":"tags","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@20"},"arguments":[]}}]},{"$type":"Group","elements":[{"$type":"Keyword","value":"type:"},{"$type":"Assignment","feature":"type","operator":"=","terminal":{"$type":"Alternatives","elements":[{"$type":"Keyword","value":"NORMAL"},{"$type":"Keyword","value":"REVERSE"},{"$type":"Keyword","value":"HIGHLIGHT"}]}}]}],"cardinality":"*"},{"$type":"RuleCall","rule":{"$ref":"#/rules@1"},"arguments":[]}]},"definesHiddenTokens":false,"entry":false,"fragment":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"ParserRule","name":"Branch","definition":{"$type":"Group","elements":[{"$type":"Keyword","value":"branch"},{"$type":"Assignment","feature":"name","operator":"=","terminal":{"$type":"Alternatives","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@19"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@20"},"arguments":[]}]}},{"$type":"Group","elements":[{"$type":"Keyword","value":"order:"},{"$type":"Assignment","feature":"order","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@18"},"arguments":[]}}],"cardinality":"?"},{"$type":"RuleCall","rule":{"$ref":"#/rules@1"},"arguments":[]}]},"definesHiddenTokens":false,"entry":false,"fragment":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"ParserRule","name":"Merge","definition":{"$type":"Group","elements":[{"$type":"Keyword","value":"merge"},{"$type":"Assignment","feature":"branch","operator":"=","terminal":{"$type":"Alternatives","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@19"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@20"},"arguments":[]}]}},{"$type":"Alternatives","elements":[{"$type":"Group","elements":[{"$type":"Keyword","value":"id:"},{"$type":"Assignment","feature":"id","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@20"},"arguments":[]}}]},{"$type":"Group","elements":[{"$type":"Keyword","value":"tag:"},{"$type":"Assignment","feature":"tags","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@20"},"arguments":[]}}]},{"$type":"Group","elements":[{"$type":"Keyword","value":"type:"},{"$type":"Assignment","feature":"type","operator":"=","terminal":{"$type":"Alternatives","elements":[{"$type":"Keyword","value":"NORMAL"},{"$type":"Keyword","value":"REVERSE"},{"$type":"Keyword","value":"HIGHLIGHT"}]}}]}],"cardinality":"*"},{"$type":"RuleCall","rule":{"$ref":"#/rules@1"},"arguments":[]}]},"definesHiddenTokens":false,"entry":false,"fragment":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"ParserRule","name":"Checkout","definition":{"$type":"Group","elements":[{"$type":"Alternatives","elements":[{"$type":"Keyword","value":"checkout"},{"$type":"Keyword","value":"switch"}]},{"$type":"Assignment","feature":"branch","operator":"=","terminal":{"$type":"Alternatives","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@19"},"arguments":[]},{"$type":"RuleCall","rule":{"$ref":"#/rules@20"},"arguments":[]}]}},{"$type":"RuleCall","rule":{"$ref":"#/rules@1"},"arguments":[]}]},"definesHiddenTokens":false,"entry":false,"fragment":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"ParserRule","name":"CherryPicking","definition":{"$type":"Group","elements":[{"$type":"Keyword","value":"cherry-pick"},{"$type":"Alternatives","elements":[{"$type":"Group","elements":[{"$type":"Keyword","value":"id:"},{"$type":"Assignment","feature":"id","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@20"},"arguments":[]}}]},{"$type":"Group","elements":[{"$type":"Keyword","value":"tag:"},{"$type":"Assignment","feature":"tags","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@20"},"arguments":[]}}]},{"$type":"Group","elements":[{"$type":"Keyword","value":"parent:"},{"$type":"Assignment","feature":"parent","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@20"},"arguments":[]}}]}],"cardinality":"*"},{"$type":"RuleCall","rule":{"$ref":"#/rules@1"},"arguments":[]}]},"definesHiddenTokens":false,"entry":false,"fragment":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"TerminalRule","name":"INT","type":{"$type":"ReturnType","name":"number"},"definition":{"$type":"RegexToken","regex":"/[0-9]+(?=\\\\s)/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ID","type":{"$type":"ReturnType","name":"string"},"definition":{"$type":"RegexToken","regex":"/\\\\w([-\\\\./\\\\w]*[-\\\\w])?/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"STRING","definition":{"$type":"RegexToken","regex":"/\\"[^\\"]*\\"|'[^']*'/"},"fragment":false,"hidden":false}],"definesHiddenTokens":false,"hiddenTokens":[],"imports":[],"types":[],"usedGrammars":[]}`)), "GitGraphGrammar");
1485 var loadedRadarGrammar;
1486 var RadarGrammar = /* @__PURE__ */ __name(() => loadedRadarGrammar ?? (loadedRadarGrammar = loadGrammarFromJson(`{"$type":"Grammar","isDeclared":true,"name":"Radar","interfaces":[{"$type":"Interface","name":"Common","attributes":[{"$type":"TypeAttribute","name":"accDescr","isOptional":true,"type":{"$type":"SimpleType","primitiveType":"string"}},{"$type":"TypeAttribute","name":"accTitle","isOptional":true,"type":{"$type":"SimpleType","primitiveType":"string"}},{"$type":"TypeAttribute","name":"title","isOptional":true,"type":{"$type":"SimpleType","primitiveType":"string"}}],"superTypes":[]},{"$type":"Interface","name":"Entry","attributes":[{"$type":"TypeAttribute","name":"axis","isOptional":true,"type":{"$type":"ReferenceType","referenceType":{"$type":"SimpleType","typeRef":{"$ref":"#/rules@12"}}}},{"$type":"TypeAttribute","name":"value","type":{"$type":"SimpleType","primitiveType":"number"},"isOptional":false}],"superTypes":[]}],"rules":[{"$type":"ParserRule","fragment":true,"name":"TitleAndAccessibilities","definition":{"$type":"Group","elements":[{"$type":"Alternatives","elements":[{"$type":"Assignment","feature":"accDescr","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@3"},"arguments":[]}},{"$type":"Assignment","feature":"accTitle","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@4"},"arguments":[]}},{"$type":"Assignment","feature":"title","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@5"},"arguments":[]}}]},{"$type":"RuleCall","rule":{"$ref":"#/rules@1"},"arguments":[]}],"cardinality":"+"},"definesHiddenTokens":false,"entry":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"ParserRule","fragment":true,"name":"EOL","dataType":"string","definition":{"$type":"Alternatives","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@2"},"arguments":[],"cardinality":"+"},{"$type":"EndOfFile"}]},"definesHiddenTokens":false,"entry":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"TerminalRule","name":"NEWLINE","definition":{"$type":"RegexToken","regex":"/\\\\r?\\\\n/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ACC_DESCR","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*accDescr(?:[\\\\t ]*:([^\\\\n\\\\r]*?(?=%%)|[^\\\\n\\\\r]*)|\\\\s*{([^}]*)})/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ACC_TITLE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*accTitle[\\\\t ]*:(?:[^\\\\n\\\\r]*?(?=%%)|[^\\\\n\\\\r]*)/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"TITLE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*title(?:[\\\\t ][^\\\\n\\\\r]*?(?=%%)|[\\\\t ][^\\\\n\\\\r]*|)/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","hidden":true,"name":"WHITESPACE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]+/"},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"YAML","definition":{"$type":"RegexToken","regex":"/---[\\\\t ]*\\\\r?\\\\n(?:[\\\\S\\\\s]*?\\\\r?\\\\n)?---(?:\\\\r?\\\\n|(?!\\\\S))/"},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"DIRECTIVE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*%%{[\\\\S\\\\s]*?}%%(?:\\\\r?\\\\n|(?!\\\\S))/"},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"SINGLE_LINE_COMMENT","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*%%[^\\\\n\\\\r]*/"},"fragment":false},{"$type":"ParserRule","entry":true,"name":"Radar","definition":{"$type":"Group","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@2"},"arguments":[],"cardinality":"*"},{"$type":"Alternatives","elements":[{"$type":"Keyword","value":"radar-beta"},{"$type":"Keyword","value":"radar-beta:"},{"$type":"Group","elements":[{"$type":"Keyword","value":"radar-beta"},{"$type":"Keyword","value":":"}]}]},{"$type":"RuleCall","rule":{"$ref":"#/rules@2"},"arguments":[],"cardinality":"*"},{"$type":"Alternatives","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@0"},"arguments":[]},{"$type":"Group","elements":[{"$type":"Keyword","value":"axis"},{"$type":"Assignment","feature":"axes","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@12"},"arguments":[]}},{"$type":"Group","elements":[{"$type":"Keyword","value":","},{"$type":"Assignment","feature":"axes","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@12"},"arguments":[]}}],"cardinality":"*"}]},{"$type":"Group","elements":[{"$type":"Keyword","value":"curve"},{"$type":"Assignment","feature":"curves","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@13"},"arguments":[]}},{"$type":"Group","elements":[{"$type":"Keyword","value":","},{"$type":"Assignment","feature":"curves","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@13"},"arguments":[]}}],"cardinality":"*"}]},{"$type":"Group","elements":[{"$type":"Assignment","feature":"options","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@17"},"arguments":[]}},{"$type":"Group","elements":[{"$type":"Keyword","value":","},{"$type":"Assignment","feature":"options","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@17"},"arguments":[]}}],"cardinality":"*"}]},{"$type":"RuleCall","rule":{"$ref":"#/rules@2"},"arguments":[]}],"cardinality":"*"}]},"definesHiddenTokens":false,"fragment":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"ParserRule","fragment":true,"name":"Label","definition":{"$type":"Group","elements":[{"$type":"Keyword","value":"["},{"$type":"Assignment","feature":"label","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@22"},"arguments":[]}},{"$type":"Keyword","value":"]"}]},"definesHiddenTokens":false,"entry":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"ParserRule","name":"Axis","definition":{"$type":"Group","elements":[{"$type":"Assignment","feature":"name","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@21"},"arguments":[]}},{"$type":"RuleCall","rule":{"$ref":"#/rules@11"},"arguments":[],"cardinality":"?"}]},"definesHiddenTokens":false,"entry":false,"fragment":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"ParserRule","name":"Curve","definition":{"$type":"Group","elements":[{"$type":"Assignment","feature":"name","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@21"},"arguments":[]}},{"$type":"RuleCall","rule":{"$ref":"#/rules@11"},"arguments":[],"cardinality":"?"},{"$type":"Keyword","value":"{"},{"$type":"RuleCall","rule":{"$ref":"#/rules@14"},"arguments":[]},{"$type":"Keyword","value":"}"}]},"definesHiddenTokens":false,"entry":false,"fragment":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"ParserRule","fragment":true,"name":"Entries","definition":{"$type":"Alternatives","elements":[{"$type":"Group","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@2"},"arguments":[],"cardinality":"*"},{"$type":"Assignment","feature":"entries","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@16"},"arguments":[]}},{"$type":"Group","elements":[{"$type":"Keyword","value":","},{"$type":"RuleCall","rule":{"$ref":"#/rules@2"},"arguments":[],"cardinality":"*"},{"$type":"Assignment","feature":"entries","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@16"},"arguments":[]}}],"cardinality":"*"},{"$type":"RuleCall","rule":{"$ref":"#/rules@2"},"arguments":[],"cardinality":"*"}]},{"$type":"Group","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@2"},"arguments":[],"cardinality":"*"},{"$type":"Assignment","feature":"entries","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@15"},"arguments":[]}},{"$type":"Group","elements":[{"$type":"Keyword","value":","},{"$type":"RuleCall","rule":{"$ref":"#/rules@2"},"arguments":[],"cardinality":"*"},{"$type":"Assignment","feature":"entries","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@15"},"arguments":[]}}],"cardinality":"*"},{"$type":"RuleCall","rule":{"$ref":"#/rules@2"},"arguments":[],"cardinality":"*"}]}]},"definesHiddenTokens":false,"entry":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"ParserRule","name":"DetailedEntry","returnType":{"$ref":"#/interfaces@1"},"definition":{"$type":"Group","elements":[{"$type":"Assignment","feature":"axis","operator":"=","terminal":{"$type":"CrossReference","type":{"$ref":"#/rules@12"},"terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@21"},"arguments":[]},"deprecatedSyntax":false}},{"$type":"Keyword","value":":","cardinality":"?"},{"$type":"Assignment","feature":"value","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@18"},"arguments":[]}}]},"definesHiddenTokens":false,"entry":false,"fragment":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"ParserRule","name":"NumberEntry","returnType":{"$ref":"#/interfaces@1"},"definition":{"$type":"Assignment","feature":"value","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@18"},"arguments":[]}},"definesHiddenTokens":false,"entry":false,"fragment":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"ParserRule","name":"Option","definition":{"$type":"Alternatives","elements":[{"$type":"Group","elements":[{"$type":"Assignment","feature":"name","operator":"=","terminal":{"$type":"Keyword","value":"showLegend"}},{"$type":"Assignment","feature":"value","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@19"},"arguments":[]}}]},{"$type":"Group","elements":[{"$type":"Assignment","feature":"name","operator":"=","terminal":{"$type":"Keyword","value":"ticks"}},{"$type":"Assignment","feature":"value","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@18"},"arguments":[]}}]},{"$type":"Group","elements":[{"$type":"Assignment","feature":"name","operator":"=","terminal":{"$type":"Keyword","value":"max"}},{"$type":"Assignment","feature":"value","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@18"},"arguments":[]}}]},{"$type":"Group","elements":[{"$type":"Assignment","feature":"name","operator":"=","terminal":{"$type":"Keyword","value":"min"}},{"$type":"Assignment","feature":"value","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@18"},"arguments":[]}}]},{"$type":"Group","elements":[{"$type":"Assignment","feature":"name","operator":"=","terminal":{"$type":"Keyword","value":"graticule"}},{"$type":"Assignment","feature":"value","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@20"},"arguments":[]}}]}]},"definesHiddenTokens":false,"entry":false,"fragment":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"TerminalRule","name":"NUMBER","type":{"$type":"ReturnType","name":"number"},"definition":{"$type":"RegexToken","regex":"/(0|[1-9][0-9]*)(\\\\.[0-9]+)?/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"BOOLEAN","type":{"$type":"ReturnType","name":"boolean"},"definition":{"$type":"TerminalAlternatives","elements":[{"$type":"CharacterRange","left":{"$type":"Keyword","value":"true"}},{"$type":"CharacterRange","left":{"$type":"Keyword","value":"false"}}]},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"GRATICULE","type":{"$type":"ReturnType","name":"string"},"definition":{"$type":"TerminalAlternatives","elements":[{"$type":"CharacterRange","left":{"$type":"Keyword","value":"circle"}},{"$type":"CharacterRange","left":{"$type":"Keyword","value":"polygon"}}]},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ID","type":{"$type":"ReturnType","name":"string"},"definition":{"$type":"RegexToken","regex":"/[a-zA-Z_][a-zA-Z0-9\\\\-_]*/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"STRING","definition":{"$type":"RegexToken","regex":"/\\"[^\\"]*\\"|'[^']*'/"},"fragment":false,"hidden":false}],"definesHiddenTokens":false,"hiddenTokens":[],"imports":[],"types":[],"usedGrammars":[]}`)), "RadarGrammar");
1487
1488 // src/language/generated/module.ts
1489 var InfoLanguageMetaData = {
1490 languageId: "info",
1491 fileExtensions: [".mmd", ".mermaid"],
1492 caseInsensitive: false,
1493 mode: "production"
1494 };
1495 var PacketLanguageMetaData = {
1496 languageId: "packet",
1497 fileExtensions: [".mmd", ".mermaid"],
1498 caseInsensitive: false,
1499 mode: "production"
1500 };
1501 var PieLanguageMetaData = {
1502 languageId: "pie",
1503 fileExtensions: [".mmd", ".mermaid"],
1504 caseInsensitive: false,
1505 mode: "production"
1506 };
1507 var ArchitectureLanguageMetaData = {
1508 languageId: "architecture",
1509 fileExtensions: [".mmd", ".mermaid"],
1510 caseInsensitive: false,
1511 mode: "production"
1512 };
1513 var GitGraphLanguageMetaData = {
1514 languageId: "gitGraph",
1515 fileExtensions: [".mmd", ".mermaid"],
1516 caseInsensitive: false,
1517 mode: "production"
1518 };
1519 var RadarLanguageMetaData = {
1520 languageId: "radar",
1521 fileExtensions: [".mmd", ".mermaid"],
1522 caseInsensitive: false,
1523 mode: "production"
1524 };
1525 var MermaidGeneratedSharedModule = {
1526 AstReflection: /* @__PURE__ */ __name(() => new MermaidAstReflection(), "AstReflection")
1527 };
1528 var InfoGeneratedModule = {
1529 Grammar: /* @__PURE__ */ __name(() => InfoGrammar(), "Grammar"),
1530 LanguageMetaData: /* @__PURE__ */ __name(() => InfoLanguageMetaData, "LanguageMetaData"),
1531 parser: {}
1532 };
1533 var PacketGeneratedModule = {
1534 Grammar: /* @__PURE__ */ __name(() => PacketGrammar(), "Grammar"),
1535 LanguageMetaData: /* @__PURE__ */ __name(() => PacketLanguageMetaData, "LanguageMetaData"),
1536 parser: {}
1537 };
1538 var PieGeneratedModule = {
1539 Grammar: /* @__PURE__ */ __name(() => PieGrammar(), "Grammar"),
1540 LanguageMetaData: /* @__PURE__ */ __name(() => PieLanguageMetaData, "LanguageMetaData"),
1541 parser: {}
1542 };
1543 var ArchitectureGeneratedModule = {
1544 Grammar: /* @__PURE__ */ __name(() => ArchitectureGrammar(), "Grammar"),
1545 LanguageMetaData: /* @__PURE__ */ __name(() => ArchitectureLanguageMetaData, "LanguageMetaData"),
1546 parser: {}
1547 };
1548 var GitGraphGeneratedModule = {
1549 Grammar: /* @__PURE__ */ __name(() => GitGraphGrammar(), "Grammar"),
1550 LanguageMetaData: /* @__PURE__ */ __name(() => GitGraphLanguageMetaData, "LanguageMetaData"),
1551 parser: {}
1552 };
1553 var RadarGeneratedModule = {
1554 Grammar: /* @__PURE__ */ __name(() => RadarGrammar(), "Grammar"),
1555 LanguageMetaData: /* @__PURE__ */ __name(() => RadarLanguageMetaData, "LanguageMetaData"),
1556 parser: {}
1557 };
1558
1559 // src/language/common/valueConverter.ts
1560
1561
1562 // src/language/common/matcher.ts
1563 var accessibilityDescrRegex = /accDescr(?:[\t ]*:([^\n\r]*)|\s*{([^}]*)})/;
1564 var accessibilityTitleRegex = /accTitle[\t ]*:([^\n\r]*)/;
1565 var titleRegex = /title([\t ][^\n\r]*|)/;
1566
1567 // src/language/common/valueConverter.ts
1568 var rulesRegexes = {
1569 ACC_DESCR: accessibilityDescrRegex,
1570 ACC_TITLE: accessibilityTitleRegex,
1571 TITLE: titleRegex
1572 };
1573 var AbstractMermaidValueConverter = class extends value_converter/* DefaultValueConverter */.t {
1574 static {
1575 __name(this, "AbstractMermaidValueConverter");
1576 }
1577 runConverter(rule, input, cstNode) {
1578 let value = this.runCommonConverter(rule, input, cstNode);
1579 if (value === void 0) {
1580 value = this.runCustomConverter(rule, input, cstNode);
1581 }
1582 if (value === void 0) {
1583 return super.runConverter(rule, input, cstNode);
1584 }
1585 return value;
1586 }
1587 runCommonConverter(rule, input, _cstNode) {
1588 const regex = rulesRegexes[rule.name];
1589 if (regex === void 0) {
1590 return void 0;
1591 }
1592 const match = regex.exec(input);
1593 if (match === null) {
1594 return void 0;
1595 }
1596 if (match[1] !== void 0) {
1597 return match[1].trim().replace(/[\t ]{2,}/gm, " ");
1598 }
1599 if (match[2] !== void 0) {
1600 return match[2].replace(/^\s*/gm, "").replace(/\s+$/gm, "").replace(/[\t ]{2,}/gm, " ").replace(/[\n\r]{2,}/gm, "\n");
1601 }
1602 return void 0;
1603 }
1604 };
1605 var CommonValueConverter = class extends AbstractMermaidValueConverter {
1606 static {
1607 __name(this, "CommonValueConverter");
1608 }
1609 runCustomConverter(_rule, _input, _cstNode) {
1610 return void 0;
1611 }
1612 };
1613
1614 // src/language/common/tokenBuilder.ts
1615
1616 var AbstractMermaidTokenBuilder = class extends token_builder/* DefaultTokenBuilder */.P {
1617 static {
1618 __name(this, "AbstractMermaidTokenBuilder");
1619 }
1620 constructor(keywords) {
1621 super();
1622 this.keywords = new Set(keywords);
1623 }
1624 buildKeywordTokens(rules, terminalTokens, options) {
1625 const tokenTypes = super.buildKeywordTokens(rules, terminalTokens, options);
1626 tokenTypes.forEach((tokenType) => {
1627 if (this.keywords.has(tokenType.name) && tokenType.PATTERN !== void 0) {
1628 tokenType.PATTERN = new RegExp(tokenType.PATTERN.toString() + "(?:(?=%%)|(?!\\S))");
1629 }
1630 });
1631 return tokenTypes;
1632 }
1633 };
1634 var CommonTokenBuilder = class extends AbstractMermaidTokenBuilder {
1635 static {
1636 __name(this, "CommonTokenBuilder");
1637 }
1638 };
1639
1640
1641
1642
1643 /***/ }),
1644
1645 /***/ 95626:
1646 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
1647
1648 "use strict";
1649 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
1650 /* harmony export */ i: () => (/* binding */ createArchitectureServices)
1651 /* harmony export */ });
1652 /* unused harmony export ArchitectureModule */
1653 /* harmony import */ var _chunk_7PKI6E2E_mjs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(60960);
1654 /* harmony import */ var langium__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(44014);
1655 /* harmony import */ var langium__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(81210);
1656 /* harmony import */ var langium__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(73001);
1657
1658
1659 // src/language/architecture/module.ts
1660
1661
1662 // src/language/architecture/tokenBuilder.ts
1663 var ArchitectureTokenBuilder = class extends _chunk_7PKI6E2E_mjs__WEBPACK_IMPORTED_MODULE_0__/* .AbstractMermaidTokenBuilder */ .T7 {
1664 static {
1665 (0,_chunk_7PKI6E2E_mjs__WEBPACK_IMPORTED_MODULE_0__/* .__name */ .eW)(this, "ArchitectureTokenBuilder");
1666 }
1667 constructor() {
1668 super(["architecture"]);
1669 }
1670 };
1671
1672 // src/language/architecture/valueConverter.ts
1673 var ArchitectureValueConverter = class extends _chunk_7PKI6E2E_mjs__WEBPACK_IMPORTED_MODULE_0__/* .AbstractMermaidValueConverter */ .kb {
1674 static {
1675 (0,_chunk_7PKI6E2E_mjs__WEBPACK_IMPORTED_MODULE_0__/* .__name */ .eW)(this, "ArchitectureValueConverter");
1676 }
1677 runCustomConverter(rule, input, _cstNode) {
1678 if (rule.name === "ARCH_ICON") {
1679 return input.replace(/[()]/g, "").trim();
1680 } else if (rule.name === "ARCH_TEXT_ICON") {
1681 return input.replace(/["()]/g, "");
1682 } else if (rule.name === "ARCH_TITLE") {
1683 return input.replace(/[[\]]/g, "").trim();
1684 }
1685 return void 0;
1686 }
1687 };
1688
1689 // src/language/architecture/module.ts
1690 var ArchitectureModule = {
1691 parser: {
1692 TokenBuilder: /* @__PURE__ */ (0,_chunk_7PKI6E2E_mjs__WEBPACK_IMPORTED_MODULE_0__/* .__name */ .eW)(() => new ArchitectureTokenBuilder(), "TokenBuilder"),
1693 ValueConverter: /* @__PURE__ */ (0,_chunk_7PKI6E2E_mjs__WEBPACK_IMPORTED_MODULE_0__/* .__name */ .eW)(() => new ArchitectureValueConverter(), "ValueConverter")
1694 }
1695 };
1696 function createArchitectureServices(context = langium__WEBPACK_IMPORTED_MODULE_1__/* .EmptyFileSystem */ .u) {
1697 const shared = (0,langium__WEBPACK_IMPORTED_MODULE_2__/* .inject */ .f3)(
1698 (0,langium__WEBPACK_IMPORTED_MODULE_3__/* .createDefaultSharedCoreModule */ .T)(context),
1699 _chunk_7PKI6E2E_mjs__WEBPACK_IMPORTED_MODULE_0__/* .MermaidGeneratedSharedModule */ .GS
1700 );
1701 const Architecture = (0,langium__WEBPACK_IMPORTED_MODULE_2__/* .inject */ .f3)(
1702 (0,langium__WEBPACK_IMPORTED_MODULE_3__/* .createDefaultCoreModule */ .Q)({ shared }),
1703 _chunk_7PKI6E2E_mjs__WEBPACK_IMPORTED_MODULE_0__/* .ArchitectureGeneratedModule */ .Qr,
1704 ArchitectureModule
1705 );
1706 shared.ServiceRegistry.register(Architecture);
1707 return { shared, Architecture };
1708 }
1709 (0,_chunk_7PKI6E2E_mjs__WEBPACK_IMPORTED_MODULE_0__/* .__name */ .eW)(createArchitectureServices, "createArchitectureServices");
1710
1711
1712
1713
1714 /***/ }),
1715
1716 /***/ 63809:
1717 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
1718
1719 "use strict";
1720 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
1721 /* harmony export */ M: () => (/* binding */ createInfoServices)
1722 /* harmony export */ });
1723 /* unused harmony export InfoModule */
1724 /* harmony import */ var _chunk_7PKI6E2E_mjs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(60960);
1725 /* harmony import */ var langium__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(44014);
1726 /* harmony import */ var langium__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(81210);
1727 /* harmony import */ var langium__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(73001);
1728
1729
1730 // src/language/info/module.ts
1731
1732
1733 // src/language/info/tokenBuilder.ts
1734 var InfoTokenBuilder = class extends _chunk_7PKI6E2E_mjs__WEBPACK_IMPORTED_MODULE_0__/* .AbstractMermaidTokenBuilder */ .T7 {
1735 static {
1736 (0,_chunk_7PKI6E2E_mjs__WEBPACK_IMPORTED_MODULE_0__/* .__name */ .eW)(this, "InfoTokenBuilder");
1737 }
1738 constructor() {
1739 super(["info", "showInfo"]);
1740 }
1741 };
1742
1743 // src/language/info/module.ts
1744 var InfoModule = {
1745 parser: {
1746 TokenBuilder: /* @__PURE__ */ (0,_chunk_7PKI6E2E_mjs__WEBPACK_IMPORTED_MODULE_0__/* .__name */ .eW)(() => new InfoTokenBuilder(), "TokenBuilder"),
1747 ValueConverter: /* @__PURE__ */ (0,_chunk_7PKI6E2E_mjs__WEBPACK_IMPORTED_MODULE_0__/* .__name */ .eW)(() => new _chunk_7PKI6E2E_mjs__WEBPACK_IMPORTED_MODULE_0__/* .CommonValueConverter */ .nr(), "ValueConverter")
1748 }
1749 };
1750 function createInfoServices(context = langium__WEBPACK_IMPORTED_MODULE_1__/* .EmptyFileSystem */ .u) {
1751 const shared = (0,langium__WEBPACK_IMPORTED_MODULE_2__/* .inject */ .f3)(
1752 (0,langium__WEBPACK_IMPORTED_MODULE_3__/* .createDefaultSharedCoreModule */ .T)(context),
1753 _chunk_7PKI6E2E_mjs__WEBPACK_IMPORTED_MODULE_0__/* .MermaidGeneratedSharedModule */ .GS
1754 );
1755 const Info = (0,langium__WEBPACK_IMPORTED_MODULE_2__/* .inject */ .f3)(
1756 (0,langium__WEBPACK_IMPORTED_MODULE_3__/* .createDefaultCoreModule */ .Q)({ shared }),
1757 _chunk_7PKI6E2E_mjs__WEBPACK_IMPORTED_MODULE_0__/* .InfoGeneratedModule */ .F_,
1758 InfoModule
1759 );
1760 shared.ServiceRegistry.register(Info);
1761 return { shared, Info };
1762 }
1763 (0,_chunk_7PKI6E2E_mjs__WEBPACK_IMPORTED_MODULE_0__/* .__name */ .eW)(createInfoServices, "createInfoServices");
1764
1765
1766
1767
1768 /***/ }),
1769
1770 /***/ 76150:
1771 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
1772
1773 "use strict";
1774 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
1775 /* harmony export */ l: () => (/* binding */ createPieServices)
1776 /* harmony export */ });
1777 /* unused harmony export PieModule */
1778 /* harmony import */ var _chunk_7PKI6E2E_mjs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(60960);
1779 /* harmony import */ var langium__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(44014);
1780 /* harmony import */ var langium__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(81210);
1781 /* harmony import */ var langium__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(73001);
1782
1783
1784 // src/language/pie/module.ts
1785
1786
1787 // src/language/pie/tokenBuilder.ts
1788 var PieTokenBuilder = class extends _chunk_7PKI6E2E_mjs__WEBPACK_IMPORTED_MODULE_0__/* .AbstractMermaidTokenBuilder */ .T7 {
1789 static {
1790 (0,_chunk_7PKI6E2E_mjs__WEBPACK_IMPORTED_MODULE_0__/* .__name */ .eW)(this, "PieTokenBuilder");
1791 }
1792 constructor() {
1793 super(["pie", "showData"]);
1794 }
1795 };
1796
1797 // src/language/pie/valueConverter.ts
1798 var PieValueConverter = class extends _chunk_7PKI6E2E_mjs__WEBPACK_IMPORTED_MODULE_0__/* .AbstractMermaidValueConverter */ .kb {
1799 static {
1800 (0,_chunk_7PKI6E2E_mjs__WEBPACK_IMPORTED_MODULE_0__/* .__name */ .eW)(this, "PieValueConverter");
1801 }
1802 runCustomConverter(rule, input, _cstNode) {
1803 if (rule.name !== "PIE_SECTION_LABEL") {
1804 return void 0;
1805 }
1806 return input.replace(/"/g, "").trim();
1807 }
1808 };
1809
1810 // src/language/pie/module.ts
1811 var PieModule = {
1812 parser: {
1813 TokenBuilder: /* @__PURE__ */ (0,_chunk_7PKI6E2E_mjs__WEBPACK_IMPORTED_MODULE_0__/* .__name */ .eW)(() => new PieTokenBuilder(), "TokenBuilder"),
1814 ValueConverter: /* @__PURE__ */ (0,_chunk_7PKI6E2E_mjs__WEBPACK_IMPORTED_MODULE_0__/* .__name */ .eW)(() => new PieValueConverter(), "ValueConverter")
1815 }
1816 };
1817 function createPieServices(context = langium__WEBPACK_IMPORTED_MODULE_1__/* .EmptyFileSystem */ .u) {
1818 const shared = (0,langium__WEBPACK_IMPORTED_MODULE_2__/* .inject */ .f3)(
1819 (0,langium__WEBPACK_IMPORTED_MODULE_3__/* .createDefaultSharedCoreModule */ .T)(context),
1820 _chunk_7PKI6E2E_mjs__WEBPACK_IMPORTED_MODULE_0__/* .MermaidGeneratedSharedModule */ .GS
1821 );
1822 const Pie = (0,langium__WEBPACK_IMPORTED_MODULE_2__/* .inject */ .f3)(
1823 (0,langium__WEBPACK_IMPORTED_MODULE_3__/* .createDefaultCoreModule */ .Q)({ shared }),
1824 _chunk_7PKI6E2E_mjs__WEBPACK_IMPORTED_MODULE_0__/* .PieGeneratedModule */ .WH,
1825 PieModule
1826 );
1827 shared.ServiceRegistry.register(Pie);
1828 return { shared, Pie };
1829 }
1830 (0,_chunk_7PKI6E2E_mjs__WEBPACK_IMPORTED_MODULE_0__/* .__name */ .eW)(createPieServices, "createPieServices");
1831
1832
1833
1834
1835 /***/ }),
1836
1837 /***/ 89053:
1838 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
1839
1840 "use strict";
1841 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
1842 /* harmony export */ g: () => (/* binding */ createPacketServices)
1843 /* harmony export */ });
1844 /* unused harmony export PacketModule */
1845 /* harmony import */ var _chunk_7PKI6E2E_mjs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(60960);
1846 /* harmony import */ var langium__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(44014);
1847 /* harmony import */ var langium__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(81210);
1848 /* harmony import */ var langium__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(73001);
1849
1850
1851 // src/language/packet/module.ts
1852
1853
1854 // src/language/packet/tokenBuilder.ts
1855 var PacketTokenBuilder = class extends _chunk_7PKI6E2E_mjs__WEBPACK_IMPORTED_MODULE_0__/* .AbstractMermaidTokenBuilder */ .T7 {
1856 static {
1857 (0,_chunk_7PKI6E2E_mjs__WEBPACK_IMPORTED_MODULE_0__/* .__name */ .eW)(this, "PacketTokenBuilder");
1858 }
1859 constructor() {
1860 super(["packet-beta"]);
1861 }
1862 };
1863
1864 // src/language/packet/module.ts
1865 var PacketModule = {
1866 parser: {
1867 TokenBuilder: /* @__PURE__ */ (0,_chunk_7PKI6E2E_mjs__WEBPACK_IMPORTED_MODULE_0__/* .__name */ .eW)(() => new PacketTokenBuilder(), "TokenBuilder"),
1868 ValueConverter: /* @__PURE__ */ (0,_chunk_7PKI6E2E_mjs__WEBPACK_IMPORTED_MODULE_0__/* .__name */ .eW)(() => new _chunk_7PKI6E2E_mjs__WEBPACK_IMPORTED_MODULE_0__/* .CommonValueConverter */ .nr(), "ValueConverter")
1869 }
1870 };
1871 function createPacketServices(context = langium__WEBPACK_IMPORTED_MODULE_1__/* .EmptyFileSystem */ .u) {
1872 const shared = (0,langium__WEBPACK_IMPORTED_MODULE_2__/* .inject */ .f3)(
1873 (0,langium__WEBPACK_IMPORTED_MODULE_3__/* .createDefaultSharedCoreModule */ .T)(context),
1874 _chunk_7PKI6E2E_mjs__WEBPACK_IMPORTED_MODULE_0__/* .MermaidGeneratedSharedModule */ .GS
1875 );
1876 const Packet = (0,langium__WEBPACK_IMPORTED_MODULE_2__/* .inject */ .f3)(
1877 (0,langium__WEBPACK_IMPORTED_MODULE_3__/* .createDefaultCoreModule */ .Q)({ shared }),
1878 _chunk_7PKI6E2E_mjs__WEBPACK_IMPORTED_MODULE_0__/* .PacketGeneratedModule */ .bb,
1879 PacketModule
1880 );
1881 shared.ServiceRegistry.register(Packet);
1882 return { shared, Packet };
1883 }
1884 (0,_chunk_7PKI6E2E_mjs__WEBPACK_IMPORTED_MODULE_0__/* .__name */ .eW)(createPacketServices, "createPacketServices");
1885
1886
1887
1888
1889 /***/ }),
1890
1891 /***/ 13197:
1892 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
1893
1894 "use strict";
1895 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
1896 /* harmony export */ Qc: () => (/* binding */ parse)
1897 /* harmony export */ });
1898 /* unused harmony export MermaidParseError */
1899 /* harmony import */ var _chunks_mermaid_parser_core_chunk_2NYFTIL2_mjs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(20078);
1900 /* harmony import */ var _chunks_mermaid_parser_core_chunk_EXZZNE6F_mjs__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(63809);
1901 /* harmony import */ var _chunks_mermaid_parser_core_chunk_V4Q32G6S_mjs__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(89053);
1902 /* harmony import */ var _chunks_mermaid_parser_core_chunk_ROXG7S4E_mjs__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(76150);
1903 /* harmony import */ var _chunks_mermaid_parser_core_chunk_C4OEIS7N_mjs__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(95626);
1904 /* harmony import */ var _chunks_mermaid_parser_core_chunk_2O5ZK7RR_mjs__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(51991);
1905 /* harmony import */ var _chunks_mermaid_parser_core_chunk_7PKI6E2E_mjs__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(60960);
1906
1907
1908
1909
1910
1911
1912
1913
1914 // src/parse.ts
1915 var parsers = {};
1916 var initializers = {
1917 info: /* @__PURE__ */ (0,_chunks_mermaid_parser_core_chunk_7PKI6E2E_mjs__WEBPACK_IMPORTED_MODULE_6__/* .__name */ .eW)(async () => {
1918 const { createInfoServices: createInfoServices2 } = await __webpack_require__.e(/* import() */ 4828).then(__webpack_require__.bind(__webpack_require__, 14828));
1919 const parser = createInfoServices2().Info.parser.LangiumParser;
1920 parsers.info = parser;
1921 }, "info"),
1922 packet: /* @__PURE__ */ (0,_chunks_mermaid_parser_core_chunk_7PKI6E2E_mjs__WEBPACK_IMPORTED_MODULE_6__/* .__name */ .eW)(async () => {
1923 const { createPacketServices: createPacketServices2 } = await __webpack_require__.e(/* import() */ 339).then(__webpack_require__.bind(__webpack_require__, 90339));
1924 const parser = createPacketServices2().Packet.parser.LangiumParser;
1925 parsers.packet = parser;
1926 }, "packet"),
1927 pie: /* @__PURE__ */ (0,_chunks_mermaid_parser_core_chunk_7PKI6E2E_mjs__WEBPACK_IMPORTED_MODULE_6__/* .__name */ .eW)(async () => {
1928 const { createPieServices: createPieServices2 } = await __webpack_require__.e(/* import() */ 6561).then(__webpack_require__.bind(__webpack_require__, 96561));
1929 const parser = createPieServices2().Pie.parser.LangiumParser;
1930 parsers.pie = parser;
1931 }, "pie"),
1932 architecture: /* @__PURE__ */ (0,_chunks_mermaid_parser_core_chunk_7PKI6E2E_mjs__WEBPACK_IMPORTED_MODULE_6__/* .__name */ .eW)(async () => {
1933 const { createArchitectureServices: createArchitectureServices2 } = await __webpack_require__.e(/* import() */ 6800).then(__webpack_require__.bind(__webpack_require__, 96800));
1934 const parser = createArchitectureServices2().Architecture.parser.LangiumParser;
1935 parsers.architecture = parser;
1936 }, "architecture"),
1937 gitGraph: /* @__PURE__ */ (0,_chunks_mermaid_parser_core_chunk_7PKI6E2E_mjs__WEBPACK_IMPORTED_MODULE_6__/* .__name */ .eW)(async () => {
1938 const { createGitGraphServices: createGitGraphServices2 } = await __webpack_require__.e(/* import() */ 9322).then(__webpack_require__.bind(__webpack_require__, 59322));
1939 const parser = createGitGraphServices2().GitGraph.parser.LangiumParser;
1940 parsers.gitGraph = parser;
1941 }, "gitGraph"),
1942 radar: /* @__PURE__ */ (0,_chunks_mermaid_parser_core_chunk_7PKI6E2E_mjs__WEBPACK_IMPORTED_MODULE_6__/* .__name */ .eW)(async () => {
1943 const { createRadarServices: createRadarServices2 } = await __webpack_require__.e(/* import() */ 3076).then(__webpack_require__.bind(__webpack_require__, 73076));
1944 const parser = createRadarServices2().Radar.parser.LangiumParser;
1945 parsers.radar = parser;
1946 }, "radar")
1947 };
1948 async function parse(diagramType, text) {
1949 const initializer = initializers[diagramType];
1950 if (!initializer) {
1951 throw new Error(`Unknown diagram type: ${diagramType}`);
1952 }
1953 if (!parsers[diagramType]) {
1954 await initializer();
1955 }
1956 const parser = parsers[diagramType];
1957 const result = parser.parse(text);
1958 if (result.lexerErrors.length > 0 || result.parserErrors.length > 0) {
1959 throw new MermaidParseError(result);
1960 }
1961 return result.value;
1962 }
1963 (0,_chunks_mermaid_parser_core_chunk_7PKI6E2E_mjs__WEBPACK_IMPORTED_MODULE_6__/* .__name */ .eW)(parse, "parse");
1964 var MermaidParseError = class extends Error {
1965 constructor(result) {
1966 const lexerErrors = result.lexerErrors.map((err) => err.message).join("\n");
1967 const parserErrors = result.parserErrors.map((err) => err.message).join("\n");
1968 super(`Parsing failed: ${lexerErrors} ${parserErrors}`);
1969 this.result = result;
1970 }
1971 static {
1972 (0,_chunks_mermaid_parser_core_chunk_7PKI6E2E_mjs__WEBPACK_IMPORTED_MODULE_6__/* .__name */ .eW)(this, "MermaidParseError");
1973 }
1974 };
1975
1976
1977
1978 /***/ }),
1979
1980 /***/ 34326:
1981 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
1982
1983 "use strict";
1984
1985 // EXPORTS
1986 __webpack_require__.d(__webpack_exports__, {
1987 ue: () => (/* reexport */ Alternation),
1988 _o: () => (/* reexport */ EMPTY_ALT),
1989 sd: () => (/* reexport */ EOF),
1990 nu: () => (/* reexport */ EmbeddedActionsParser),
1991 dV: () => (/* reexport */ LLkLookaheadStrategy),
1992 hW: () => (/* reexport */ Lexer),
1993 Sj: () => (/* reexport */ NonTerminal),
1994 Wx: () => (/* reexport */ Option),
1995 hI: () => (/* reexport */ Repetition),
1996 ej: () => (/* reexport */ RepetitionMandatory),
1997 fK: () => (/* reexport */ RepetitionMandatoryWithSeparator),
1998 pT: () => (/* reexport */ RepetitionWithSeparator),
1999 oI: () => (/* reexport */ Terminal),
2000 ZW: () => (/* reexport */ defaultLexerErrorProvider),
2001 Hs: () => (/* reexport */ defaultParserErrorProvider),
2002 oC: () => (/* reexport */ getLookaheadPaths),
2003 l$: () => (/* reexport */ tokens_public_tokenLabel),
2004 ol: () => (/* reexport */ tokenMatcher)
2005 });
2006
2007 // UNUSED EXPORTS: Alternative, CstParser, EarlyExitException, GAstVisitor, LexerDefinitionErrorType, MismatchedTokenException, NoViableAltException, NotAllInputParsedException, Parser, ParserDefinitionErrorType, Rule, VERSION, clearCache, createSyntaxDiagramsCode, createToken, createTokenInstance, generateCstDts, isRecognitionException, serializeGrammar, serializeProduction, tokenName
2008
2009 // EXTERNAL MODULE: ../node_modules/lodash-es/forEach.js
2010 var forEach = __webpack_require__(21845);
2011 // EXTERNAL MODULE: ../node_modules/lodash-es/values.js + 1 modules
2012 var values = __webpack_require__(88873);
2013 // EXTERNAL MODULE: ../node_modules/lodash-es/isEmpty.js
2014 var isEmpty = __webpack_require__(66400);
2015 // EXTERNAL MODULE: ../node_modules/lodash-es/map.js
2016 var map = __webpack_require__(12930);
2017 // EXTERNAL MODULE: ../node_modules/lodash-es/has.js + 1 modules
2018 var has = __webpack_require__(36004);
2019 // EXTERNAL MODULE: ../node_modules/lodash-es/clone.js
2020 var lodash_es_clone = __webpack_require__(20190);
2021 ;// CONCATENATED MODULE: ../node_modules/@chevrotain/utils/lib/src/to-fast-properties.js
2022 // based on: https://github.com/petkaantonov/bluebird/blob/b97c0d2d487e8c5076e8bd897e0dcd4622d31846/src/util.js#L201-L216
2023 function toFastProperties(toBecomeFast) {
2024 function FakeConstructor() { }
2025 // If our object is used as a constructor, it would receive
2026 FakeConstructor.prototype = toBecomeFast;
2027 const fakeInstance = new FakeConstructor();
2028 function fakeAccess() {
2029 return typeof fakeInstance.bar;
2030 }
2031 // help V8 understand this is a "real" prototype by actually using
2032 // the fake instance.
2033 fakeAccess();
2034 fakeAccess();
2035 // Always true condition to suppress the Firefox warning of unreachable
2036 // code after a return statement.
2037 if (true)
2038 return toBecomeFast;
2039 // Eval prevents optimization of this method (even though this is dead code)
2040 // - https://esbuild.github.io/content-types/#direct-eval
2041 /* istanbul ignore next */
2042 // tslint:disable-next-line
2043 (0, eval)(toBecomeFast);
2044 }
2045 //# sourceMappingURL=to-fast-properties.js.map
2046 ;// CONCATENATED MODULE: ../node_modules/lodash-es/_baseSlice.js
2047 /**
2048 * The base implementation of `_.slice` without an iteratee call guard.
2049 *
2050 * @private
2051 * @param {Array} array The array to slice.
2052 * @param {number} [start=0] The start position.
2053 * @param {number} [end=array.length] The end position.
2054 * @returns {Array} Returns the slice of `array`.
2055 */
2056 function baseSlice(array, start, end) {
2057 var index = -1,
2058 length = array.length;
2059
2060 if (start < 0) {
2061 start = -start > length ? 0 : (length + start);
2062 }
2063 end = end > length ? length : end;
2064 if (end < 0) {
2065 end += length;
2066 }
2067 length = start > end ? 0 : ((end - start) >>> 0);
2068 start >>>= 0;
2069
2070 var result = Array(length);
2071 while (++index < length) {
2072 result[index] = array[index + start];
2073 }
2074 return result;
2075 }
2076
2077 /* harmony default export */ const _baseSlice = (baseSlice);
2078
2079 // EXTERNAL MODULE: ../node_modules/lodash-es/toInteger.js
2080 var toInteger = __webpack_require__(98670);
2081 ;// CONCATENATED MODULE: ../node_modules/lodash-es/drop.js
2082
2083
2084
2085 /**
2086 * Creates a slice of `array` with `n` elements dropped from the beginning.
2087 *
2088 * @static
2089 * @memberOf _
2090 * @since 0.5.0
2091 * @category Array
2092 * @param {Array} array The array to query.
2093 * @param {number} [n=1] The number of elements to drop.
2094 * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
2095 * @returns {Array} Returns the slice of `array`.
2096 * @example
2097 *
2098 * _.drop([1, 2, 3]);
2099 * // => [2, 3]
2100 *
2101 * _.drop([1, 2, 3], 2);
2102 * // => [3]
2103 *
2104 * _.drop([1, 2, 3], 5);
2105 * // => []
2106 *
2107 * _.drop([1, 2, 3], 0);
2108 * // => [1, 2, 3]
2109 */
2110 function drop(array, n, guard) {
2111 var length = array == null ? 0 : array.length;
2112 if (!length) {
2113 return [];
2114 }
2115 n = (guard || n === undefined) ? 1 : (0,toInteger/* default */.Z)(n);
2116 return _baseSlice(array, n < 0 ? 0 : n, length);
2117 }
2118
2119 /* harmony default export */ const lodash_es_drop = (drop);
2120
2121 // EXTERNAL MODULE: ../node_modules/lodash-es/isString.js
2122 var isString = __webpack_require__(75732);
2123 // EXTERNAL MODULE: ../node_modules/lodash-es/_assignValue.js
2124 var _assignValue = __webpack_require__(15561);
2125 // EXTERNAL MODULE: ../node_modules/lodash-es/_copyObject.js
2126 var _copyObject = __webpack_require__(47313);
2127 // EXTERNAL MODULE: ../node_modules/lodash-es/_createAssigner.js
2128 var _createAssigner = __webpack_require__(40690);
2129 // EXTERNAL MODULE: ../node_modules/lodash-es/isArrayLike.js
2130 var isArrayLike = __webpack_require__(69959);
2131 // EXTERNAL MODULE: ../node_modules/lodash-es/_isPrototype.js
2132 var _isPrototype = __webpack_require__(89418);
2133 // EXTERNAL MODULE: ../node_modules/lodash-es/keys.js
2134 var keys = __webpack_require__(11723);
2135 ;// CONCATENATED MODULE: ../node_modules/lodash-es/assign.js
2136
2137
2138
2139
2140
2141
2142
2143 /** Used for built-in method references. */
2144 var objectProto = Object.prototype;
2145
2146 /** Used to check objects for own properties. */
2147 var assign_hasOwnProperty = objectProto.hasOwnProperty;
2148
2149 /**
2150 * Assigns own enumerable string keyed properties of source objects to the
2151 * destination object. Source objects are applied from left to right.
2152 * Subsequent sources overwrite property assignments of previous sources.
2153 *
2154 * **Note:** This method mutates `object` and is loosely based on
2155 * [`Object.assign`](https://mdn.io/Object/assign).
2156 *
2157 * @static
2158 * @memberOf _
2159 * @since 0.10.0
2160 * @category Object
2161 * @param {Object} object The destination object.
2162 * @param {...Object} [sources] The source objects.
2163 * @returns {Object} Returns `object`.
2164 * @see _.assignIn
2165 * @example
2166 *
2167 * function Foo() {
2168 * this.a = 1;
2169 * }
2170 *
2171 * function Bar() {
2172 * this.c = 3;
2173 * }
2174 *
2175 * Foo.prototype.b = 2;
2176 * Bar.prototype.d = 4;
2177 *
2178 * _.assign({ 'a': 0 }, new Foo, new Bar);
2179 * // => { 'a': 1, 'c': 3 }
2180 */
2181 var assign_assign = (0,_createAssigner/* default */.Z)(function(object, source) {
2182 if ((0,_isPrototype/* default */.Z)(source) || (0,isArrayLike/* default */.Z)(source)) {
2183 (0,_copyObject/* default */.Z)(source, (0,keys/* default */.Z)(source), object);
2184 return;
2185 }
2186 for (var key in source) {
2187 if (assign_hasOwnProperty.call(source, key)) {
2188 (0,_assignValue/* default */.Z)(object, key, source[key]);
2189 }
2190 }
2191 });
2192
2193 /* harmony default export */ const lodash_es_assign = (assign_assign);
2194
2195 // EXTERNAL MODULE: ../node_modules/lodash-es/_arrayMap.js
2196 var _arrayMap = __webpack_require__(33043);
2197 // EXTERNAL MODULE: ../node_modules/lodash-es/_baseIteratee.js + 15 modules
2198 var _baseIteratee = __webpack_require__(86494);
2199 // EXTERNAL MODULE: ../node_modules/lodash-es/_basePickBy.js + 1 modules
2200 var _basePickBy = __webpack_require__(73338);
2201 // EXTERNAL MODULE: ../node_modules/lodash-es/_getAllKeysIn.js
2202 var _getAllKeysIn = __webpack_require__(5206);
2203 ;// CONCATENATED MODULE: ../node_modules/lodash-es/pickBy.js
2204
2205
2206
2207
2208
2209 /**
2210 * Creates an object composed of the `object` properties `predicate` returns
2211 * truthy for. The predicate is invoked with two arguments: (value, key).
2212 *
2213 * @static
2214 * @memberOf _
2215 * @since 4.0.0
2216 * @category Object
2217 * @param {Object} object The source object.
2218 * @param {Function} [predicate=_.identity] The function invoked per property.
2219 * @returns {Object} Returns the new object.
2220 * @example
2221 *
2222 * var object = { 'a': 1, 'b': '2', 'c': 3 };
2223 *
2224 * _.pickBy(object, _.isNumber);
2225 * // => { 'a': 1, 'c': 3 }
2226 */
2227 function pickBy(object, predicate) {
2228 if (object == null) {
2229 return {};
2230 }
2231 var props = (0,_arrayMap/* default */.Z)((0,_getAllKeysIn/* default */.Z)(object), function(prop) {
2232 return [prop];
2233 });
2234 predicate = (0,_baseIteratee/* default */.Z)(predicate);
2235 return (0,_basePickBy/* default */.Z)(object, props, function(value, path) {
2236 return predicate(value, path[0]);
2237 });
2238 }
2239
2240 /* harmony default export */ const lodash_es_pickBy = (pickBy);
2241
2242 // EXTERNAL MODULE: ../node_modules/lodash-es/_baseGetTag.js + 2 modules
2243 var _baseGetTag = __webpack_require__(77070);
2244 // EXTERNAL MODULE: ../node_modules/lodash-es/isObjectLike.js
2245 var isObjectLike = __webpack_require__(9615);
2246 ;// CONCATENATED MODULE: ../node_modules/lodash-es/_baseIsRegExp.js
2247
2248
2249
2250 /** `Object#toString` result references. */
2251 var regexpTag = '[object RegExp]';
2252
2253 /**
2254 * The base implementation of `_.isRegExp` without Node.js optimizations.
2255 *
2256 * @private
2257 * @param {*} value The value to check.
2258 * @returns {boolean} Returns `true` if `value` is a regexp, else `false`.
2259 */
2260 function baseIsRegExp(value) {
2261 return (0,isObjectLike/* default */.Z)(value) && (0,_baseGetTag/* default */.Z)(value) == regexpTag;
2262 }
2263
2264 /* harmony default export */ const _baseIsRegExp = (baseIsRegExp);
2265
2266 // EXTERNAL MODULE: ../node_modules/lodash-es/_baseUnary.js
2267 var _baseUnary = __webpack_require__(20274);
2268 // EXTERNAL MODULE: ../node_modules/lodash-es/_nodeUtil.js
2269 var _nodeUtil = __webpack_require__(53594);
2270 ;// CONCATENATED MODULE: ../node_modules/lodash-es/isRegExp.js
2271
2272
2273
2274
2275 /* Node.js helper references. */
2276 var nodeIsRegExp = _nodeUtil/* default */.Z && _nodeUtil/* default */.Z.isRegExp;
2277
2278 /**
2279 * Checks if `value` is classified as a `RegExp` object.
2280 *
2281 * @static
2282 * @memberOf _
2283 * @since 0.1.0
2284 * @category Lang
2285 * @param {*} value The value to check.
2286 * @returns {boolean} Returns `true` if `value` is a regexp, else `false`.
2287 * @example
2288 *
2289 * _.isRegExp(/abc/);
2290 * // => true
2291 *
2292 * _.isRegExp('/abc/');
2293 * // => false
2294 */
2295 var isRegExp = nodeIsRegExp ? (0,_baseUnary/* default */.Z)(nodeIsRegExp) : _baseIsRegExp;
2296
2297 /* harmony default export */ const lodash_es_isRegExp = (isRegExp);
2298
2299 ;// CONCATENATED MODULE: ../node_modules/@chevrotain/gast/lib/src/model.js
2300
2301 // TODO: duplicated code to avoid extracting another sub-package -- how to avoid?
2302 function tokenLabel(tokType) {
2303 if (hasTokenLabel(tokType)) {
2304 return tokType.LABEL;
2305 }
2306 else {
2307 return tokType.name;
2308 }
2309 }
2310 // TODO: duplicated code to avoid extracting another sub-package -- how to avoid?
2311 function hasTokenLabel(obj) {
2312 return (0,isString/* default */.Z)(obj.LABEL) && obj.LABEL !== "";
2313 }
2314 class AbstractProduction {
2315 get definition() {
2316 return this._definition;
2317 }
2318 set definition(value) {
2319 this._definition = value;
2320 }
2321 constructor(_definition) {
2322 this._definition = _definition;
2323 }
2324 accept(visitor) {
2325 visitor.visit(this);
2326 (0,forEach/* default */.Z)(this.definition, (prod) => {
2327 prod.accept(visitor);
2328 });
2329 }
2330 }
2331 class NonTerminal extends AbstractProduction {
2332 constructor(options) {
2333 super([]);
2334 this.idx = 1;
2335 lodash_es_assign(this, lodash_es_pickBy(options, (v) => v !== undefined));
2336 }
2337 set definition(definition) {
2338 // immutable
2339 }
2340 get definition() {
2341 if (this.referencedRule !== undefined) {
2342 return this.referencedRule.definition;
2343 }
2344 return [];
2345 }
2346 accept(visitor) {
2347 visitor.visit(this);
2348 // don't visit children of a reference, we will get cyclic infinite loops if we do so
2349 }
2350 }
2351 class Rule extends AbstractProduction {
2352 constructor(options) {
2353 super(options.definition);
2354 this.orgText = "";
2355 lodash_es_assign(this, lodash_es_pickBy(options, (v) => v !== undefined));
2356 }
2357 }
2358 class Alternative extends AbstractProduction {
2359 constructor(options) {
2360 super(options.definition);
2361 this.ignoreAmbiguities = false;
2362 lodash_es_assign(this, lodash_es_pickBy(options, (v) => v !== undefined));
2363 }
2364 }
2365 class Option extends AbstractProduction {
2366 constructor(options) {
2367 super(options.definition);
2368 this.idx = 1;
2369 lodash_es_assign(this, lodash_es_pickBy(options, (v) => v !== undefined));
2370 }
2371 }
2372 class RepetitionMandatory extends AbstractProduction {
2373 constructor(options) {
2374 super(options.definition);
2375 this.idx = 1;
2376 lodash_es_assign(this, lodash_es_pickBy(options, (v) => v !== undefined));
2377 }
2378 }
2379 class RepetitionMandatoryWithSeparator extends AbstractProduction {
2380 constructor(options) {
2381 super(options.definition);
2382 this.idx = 1;
2383 lodash_es_assign(this, lodash_es_pickBy(options, (v) => v !== undefined));
2384 }
2385 }
2386 class Repetition extends AbstractProduction {
2387 constructor(options) {
2388 super(options.definition);
2389 this.idx = 1;
2390 lodash_es_assign(this, lodash_es_pickBy(options, (v) => v !== undefined));
2391 }
2392 }
2393 class RepetitionWithSeparator extends AbstractProduction {
2394 constructor(options) {
2395 super(options.definition);
2396 this.idx = 1;
2397 lodash_es_assign(this, lodash_es_pickBy(options, (v) => v !== undefined));
2398 }
2399 }
2400 class Alternation extends AbstractProduction {
2401 get definition() {
2402 return this._definition;
2403 }
2404 set definition(value) {
2405 this._definition = value;
2406 }
2407 constructor(options) {
2408 super(options.definition);
2409 this.idx = 1;
2410 this.ignoreAmbiguities = false;
2411 this.hasPredicates = false;
2412 lodash_es_assign(this, lodash_es_pickBy(options, (v) => v !== undefined));
2413 }
2414 }
2415 class Terminal {
2416 constructor(options) {
2417 this.idx = 1;
2418 lodash_es_assign(this, lodash_es_pickBy(options, (v) => v !== undefined));
2419 }
2420 accept(visitor) {
2421 visitor.visit(this);
2422 }
2423 }
2424 function serializeGrammar(topRules) {
2425 return (0,map/* default */.Z)(topRules, serializeProduction);
2426 }
2427 function serializeProduction(node) {
2428 function convertDefinition(definition) {
2429 return (0,map/* default */.Z)(definition, serializeProduction);
2430 }
2431 /* istanbul ignore else */
2432 if (node instanceof NonTerminal) {
2433 const serializedNonTerminal = {
2434 type: "NonTerminal",
2435 name: node.nonTerminalName,
2436 idx: node.idx,
2437 };
2438 if ((0,isString/* default */.Z)(node.label)) {
2439 serializedNonTerminal.label = node.label;
2440 }
2441 return serializedNonTerminal;
2442 }
2443 else if (node instanceof Alternative) {
2444 return {
2445 type: "Alternative",
2446 definition: convertDefinition(node.definition),
2447 };
2448 }
2449 else if (node instanceof Option) {
2450 return {
2451 type: "Option",
2452 idx: node.idx,
2453 definition: convertDefinition(node.definition),
2454 };
2455 }
2456 else if (node instanceof RepetitionMandatory) {
2457 return {
2458 type: "RepetitionMandatory",
2459 idx: node.idx,
2460 definition: convertDefinition(node.definition),
2461 };
2462 }
2463 else if (node instanceof RepetitionMandatoryWithSeparator) {
2464 return {
2465 type: "RepetitionMandatoryWithSeparator",
2466 idx: node.idx,
2467 separator: (serializeProduction(new Terminal({ terminalType: node.separator }))),
2468 definition: convertDefinition(node.definition),
2469 };
2470 }
2471 else if (node instanceof RepetitionWithSeparator) {
2472 return {
2473 type: "RepetitionWithSeparator",
2474 idx: node.idx,
2475 separator: (serializeProduction(new Terminal({ terminalType: node.separator }))),
2476 definition: convertDefinition(node.definition),
2477 };
2478 }
2479 else if (node instanceof Repetition) {
2480 return {
2481 type: "Repetition",
2482 idx: node.idx,
2483 definition: convertDefinition(node.definition),
2484 };
2485 }
2486 else if (node instanceof Alternation) {
2487 return {
2488 type: "Alternation",
2489 idx: node.idx,
2490 definition: convertDefinition(node.definition),
2491 };
2492 }
2493 else if (node instanceof Terminal) {
2494 const serializedTerminal = {
2495 type: "Terminal",
2496 name: node.terminalType.name,
2497 label: tokenLabel(node.terminalType),
2498 idx: node.idx,
2499 };
2500 if ((0,isString/* default */.Z)(node.label)) {
2501 serializedTerminal.terminalLabel = node.label;
2502 }
2503 const pattern = node.terminalType.PATTERN;
2504 if (node.terminalType.PATTERN) {
2505 serializedTerminal.pattern = lodash_es_isRegExp(pattern)
2506 ? pattern.source
2507 : pattern;
2508 }
2509 return serializedTerminal;
2510 }
2511 else if (node instanceof Rule) {
2512 return {
2513 type: "Rule",
2514 name: node.name,
2515 orgText: node.orgText,
2516 definition: convertDefinition(node.definition),
2517 };
2518 /* c8 ignore next 3 */
2519 }
2520 else {
2521 throw Error("non exhaustive match");
2522 }
2523 }
2524 //# sourceMappingURL=model.js.map
2525 ;// CONCATENATED MODULE: ../node_modules/chevrotain/lib/src/parse/grammar/rest.js
2526
2527
2528 /**
2529 * A Grammar Walker that computes the "remaining" grammar "after" a productions in the grammar.
2530 */
2531 class RestWalker {
2532 walk(prod, prevRest = []) {
2533 (0,forEach/* default */.Z)(prod.definition, (subProd, index) => {
2534 const currRest = lodash_es_drop(prod.definition, index + 1);
2535 /* istanbul ignore else */
2536 if (subProd instanceof NonTerminal) {
2537 this.walkProdRef(subProd, currRest, prevRest);
2538 }
2539 else if (subProd instanceof Terminal) {
2540 this.walkTerminal(subProd, currRest, prevRest);
2541 }
2542 else if (subProd instanceof Alternative) {
2543 this.walkFlat(subProd, currRest, prevRest);
2544 }
2545 else if (subProd instanceof Option) {
2546 this.walkOption(subProd, currRest, prevRest);
2547 }
2548 else if (subProd instanceof RepetitionMandatory) {
2549 this.walkAtLeastOne(subProd, currRest, prevRest);
2550 }
2551 else if (subProd instanceof RepetitionMandatoryWithSeparator) {
2552 this.walkAtLeastOneSep(subProd, currRest, prevRest);
2553 }
2554 else if (subProd instanceof RepetitionWithSeparator) {
2555 this.walkManySep(subProd, currRest, prevRest);
2556 }
2557 else if (subProd instanceof Repetition) {
2558 this.walkMany(subProd, currRest, prevRest);
2559 }
2560 else if (subProd instanceof Alternation) {
2561 this.walkOr(subProd, currRest, prevRest);
2562 }
2563 else {
2564 throw Error("non exhaustive match");
2565 }
2566 });
2567 }
2568 walkTerminal(terminal, currRest, prevRest) { }
2569 walkProdRef(refProd, currRest, prevRest) { }
2570 walkFlat(flatProd, currRest, prevRest) {
2571 // ABCDEF => after the D the rest is EF
2572 const fullOrRest = currRest.concat(prevRest);
2573 this.walk(flatProd, fullOrRest);
2574 }
2575 walkOption(optionProd, currRest, prevRest) {
2576 // ABC(DE)?F => after the (DE)? the rest is F
2577 const fullOrRest = currRest.concat(prevRest);
2578 this.walk(optionProd, fullOrRest);
2579 }
2580 walkAtLeastOne(atLeastOneProd, currRest, prevRest) {
2581 // ABC(DE)+F => after the (DE)+ the rest is (DE)?F
2582 const fullAtLeastOneRest = [
2583 new Option({ definition: atLeastOneProd.definition }),
2584 ].concat(currRest, prevRest);
2585 this.walk(atLeastOneProd, fullAtLeastOneRest);
2586 }
2587 walkAtLeastOneSep(atLeastOneSepProd, currRest, prevRest) {
2588 // ABC DE(,DE)* F => after the (,DE)+ the rest is (,DE)?F
2589 const fullAtLeastOneSepRest = restForRepetitionWithSeparator(atLeastOneSepProd, currRest, prevRest);
2590 this.walk(atLeastOneSepProd, fullAtLeastOneSepRest);
2591 }
2592 walkMany(manyProd, currRest, prevRest) {
2593 // ABC(DE)*F => after the (DE)* the rest is (DE)?F
2594 const fullManyRest = [
2595 new Option({ definition: manyProd.definition }),
2596 ].concat(currRest, prevRest);
2597 this.walk(manyProd, fullManyRest);
2598 }
2599 walkManySep(manySepProd, currRest, prevRest) {
2600 // ABC (DE(,DE)*)? F => after the (,DE)* the rest is (,DE)?F
2601 const fullManySepRest = restForRepetitionWithSeparator(manySepProd, currRest, prevRest);
2602 this.walk(manySepProd, fullManySepRest);
2603 }
2604 walkOr(orProd, currRest, prevRest) {
2605 // ABC(D|E|F)G => when finding the (D|E|F) the rest is G
2606 const fullOrRest = currRest.concat(prevRest);
2607 // walk all different alternatives
2608 (0,forEach/* default */.Z)(orProd.definition, (alt) => {
2609 // wrapping each alternative in a single definition wrapper
2610 // to avoid errors in computing the rest of that alternative in the invocation to computeInProdFollows
2611 // (otherwise for OR([alt1,alt2]) alt2 will be considered in 'rest' of alt1
2612 const prodWrapper = new Alternative({ definition: [alt] });
2613 this.walk(prodWrapper, fullOrRest);
2614 });
2615 }
2616 }
2617 function restForRepetitionWithSeparator(repSepProd, currRest, prevRest) {
2618 const repSepRest = [
2619 new Option({
2620 definition: [
2621 new Terminal({ terminalType: repSepProd.separator }),
2622 ].concat(repSepProd.definition),
2623 }),
2624 ];
2625 const fullRepSepRest = repSepRest.concat(currRest, prevRest);
2626 return fullRepSepRest;
2627 }
2628 //# sourceMappingURL=rest.js.map
2629 // EXTERNAL MODULE: ../node_modules/lodash-es/_baseUniq.js + 1 modules
2630 var _baseUniq = __webpack_require__(99633);
2631 ;// CONCATENATED MODULE: ../node_modules/lodash-es/uniq.js
2632
2633
2634 /**
2635 * Creates a duplicate-free version of an array, using
2636 * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
2637 * for equality comparisons, in which only the first occurrence of each element
2638 * is kept. The order of result values is determined by the order they occur
2639 * in the array.
2640 *
2641 * @static
2642 * @memberOf _
2643 * @since 0.1.0
2644 * @category Array
2645 * @param {Array} array The array to inspect.
2646 * @returns {Array} Returns the new duplicate free array.
2647 * @example
2648 *
2649 * _.uniq([2, 1, 2]);
2650 * // => [2, 1]
2651 */
2652 function uniq(array) {
2653 return (array && array.length) ? (0,_baseUniq/* default */.Z)(array) : [];
2654 }
2655
2656 /* harmony default export */ const lodash_es_uniq = (uniq);
2657
2658 // EXTERNAL MODULE: ../node_modules/lodash-es/flatten.js
2659 var flatten = __webpack_require__(28099);
2660 // EXTERNAL MODULE: ../node_modules/lodash-es/_arraySome.js
2661 var _arraySome = __webpack_require__(82964);
2662 // EXTERNAL MODULE: ../node_modules/lodash-es/_baseEach.js + 1 modules
2663 var _baseEach = __webpack_require__(77201);
2664 ;// CONCATENATED MODULE: ../node_modules/lodash-es/_baseSome.js
2665
2666
2667 /**
2668 * The base implementation of `_.some` without support for iteratee shorthands.
2669 *
2670 * @private
2671 * @param {Array|Object} collection The collection to iterate over.
2672 * @param {Function} predicate The function invoked per iteration.
2673 * @returns {boolean} Returns `true` if any element passes the predicate check,
2674 * else `false`.
2675 */
2676 function baseSome(collection, predicate) {
2677 var result;
2678
2679 (0,_baseEach/* default */.Z)(collection, function(value, index, collection) {
2680 result = predicate(value, index, collection);
2681 return !result;
2682 });
2683 return !!result;
2684 }
2685
2686 /* harmony default export */ const _baseSome = (baseSome);
2687
2688 // EXTERNAL MODULE: ../node_modules/lodash-es/isArray.js
2689 var isArray = __webpack_require__(64058);
2690 // EXTERNAL MODULE: ../node_modules/lodash-es/_isIterateeCall.js
2691 var _isIterateeCall = __webpack_require__(47952);
2692 ;// CONCATENATED MODULE: ../node_modules/lodash-es/some.js
2693
2694
2695
2696
2697
2698
2699 /**
2700 * Checks if `predicate` returns truthy for **any** element of `collection`.
2701 * Iteration is stopped once `predicate` returns truthy. The predicate is
2702 * invoked with three arguments: (value, index|key, collection).
2703 *
2704 * @static
2705 * @memberOf _
2706 * @since 0.1.0
2707 * @category Collection
2708 * @param {Array|Object} collection The collection to iterate over.
2709 * @param {Function} [predicate=_.identity] The function invoked per iteration.
2710 * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
2711 * @returns {boolean} Returns `true` if any element passes the predicate check,
2712 * else `false`.
2713 * @example
2714 *
2715 * _.some([null, 0, 'yes', false], Boolean);
2716 * // => true
2717 *
2718 * var users = [
2719 * { 'user': 'barney', 'active': true },
2720 * { 'user': 'fred', 'active': false }
2721 * ];
2722 *
2723 * // The `_.matches` iteratee shorthand.
2724 * _.some(users, { 'user': 'barney', 'active': false });
2725 * // => false
2726 *
2727 * // The `_.matchesProperty` iteratee shorthand.
2728 * _.some(users, ['active', false]);
2729 * // => true
2730 *
2731 * // The `_.property` iteratee shorthand.
2732 * _.some(users, 'active');
2733 * // => true
2734 */
2735 function some(collection, predicate, guard) {
2736 var func = (0,isArray/* default */.Z)(collection) ? _arraySome/* default */.Z : _baseSome;
2737 if (guard && (0,_isIterateeCall/* default */.Z)(collection, predicate, guard)) {
2738 predicate = undefined;
2739 }
2740 return func(collection, (0,_baseIteratee/* default */.Z)(predicate, 3));
2741 }
2742
2743 /* harmony default export */ const lodash_es_some = (some);
2744
2745 // EXTERNAL MODULE: ../node_modules/lodash-es/_baseIndexOf.js + 2 modules
2746 var _baseIndexOf = __webpack_require__(90393);
2747 ;// CONCATENATED MODULE: ../node_modules/lodash-es/includes.js
2748
2749
2750
2751
2752
2753
2754 /* Built-in method references for those with the same name as other `lodash` methods. */
2755 var nativeMax = Math.max;
2756
2757 /**
2758 * Checks if `value` is in `collection`. If `collection` is a string, it's
2759 * checked for a substring of `value`, otherwise
2760 * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
2761 * is used for equality comparisons. If `fromIndex` is negative, it's used as
2762 * the offset from the end of `collection`.
2763 *
2764 * @static
2765 * @memberOf _
2766 * @since 0.1.0
2767 * @category Collection
2768 * @param {Array|Object|string} collection The collection to inspect.
2769 * @param {*} value The value to search for.
2770 * @param {number} [fromIndex=0] The index to search from.
2771 * @param- {Object} [guard] Enables use as an iteratee for methods like `_.reduce`.
2772 * @returns {boolean} Returns `true` if `value` is found, else `false`.
2773 * @example
2774 *
2775 * _.includes([1, 2, 3], 1);
2776 * // => true
2777 *
2778 * _.includes([1, 2, 3], 1, 2);
2779 * // => false
2780 *
2781 * _.includes({ 'a': 1, 'b': 2 }, 1);
2782 * // => true
2783 *
2784 * _.includes('abcd', 'bc');
2785 * // => true
2786 */
2787 function includes(collection, value, fromIndex, guard) {
2788 collection = (0,isArrayLike/* default */.Z)(collection) ? collection : (0,values/* default */.Z)(collection);
2789 fromIndex = (fromIndex && !guard) ? (0,toInteger/* default */.Z)(fromIndex) : 0;
2790
2791 var length = collection.length;
2792 if (fromIndex < 0) {
2793 fromIndex = nativeMax(length + fromIndex, 0);
2794 }
2795 return (0,isString/* default */.Z)(collection)
2796 ? (fromIndex <= length && collection.indexOf(value, fromIndex) > -1)
2797 : (!!length && (0,_baseIndexOf/* default */.Z)(collection, value, fromIndex) > -1);
2798 }
2799
2800 /* harmony default export */ const lodash_es_includes = (includes);
2801
2802 ;// CONCATENATED MODULE: ../node_modules/lodash-es/_arrayEvery.js
2803 /**
2804 * A specialized version of `_.every` for arrays without support for
2805 * iteratee shorthands.
2806 *
2807 * @private
2808 * @param {Array} [array] The array to iterate over.
2809 * @param {Function} predicate The function invoked per iteration.
2810 * @returns {boolean} Returns `true` if all elements pass the predicate check,
2811 * else `false`.
2812 */
2813 function arrayEvery(array, predicate) {
2814 var index = -1,
2815 length = array == null ? 0 : array.length;
2816
2817 while (++index < length) {
2818 if (!predicate(array[index], index, array)) {
2819 return false;
2820 }
2821 }
2822 return true;
2823 }
2824
2825 /* harmony default export */ const _arrayEvery = (arrayEvery);
2826
2827 ;// CONCATENATED MODULE: ../node_modules/lodash-es/_baseEvery.js
2828
2829
2830 /**
2831 * The base implementation of `_.every` without support for iteratee shorthands.
2832 *
2833 * @private
2834 * @param {Array|Object} collection The collection to iterate over.
2835 * @param {Function} predicate The function invoked per iteration.
2836 * @returns {boolean} Returns `true` if all elements pass the predicate check,
2837 * else `false`
2838 */
2839 function baseEvery(collection, predicate) {
2840 var result = true;
2841 (0,_baseEach/* default */.Z)(collection, function(value, index, collection) {
2842 result = !!predicate(value, index, collection);
2843 return result;
2844 });
2845 return result;
2846 }
2847
2848 /* harmony default export */ const _baseEvery = (baseEvery);
2849
2850 ;// CONCATENATED MODULE: ../node_modules/lodash-es/every.js
2851
2852
2853
2854
2855
2856
2857 /**
2858 * Checks if `predicate` returns truthy for **all** elements of `collection`.
2859 * Iteration is stopped once `predicate` returns falsey. The predicate is
2860 * invoked with three arguments: (value, index|key, collection).
2861 *
2862 * **Note:** This method returns `true` for
2863 * [empty collections](https://en.wikipedia.org/wiki/Empty_set) because
2864 * [everything is true](https://en.wikipedia.org/wiki/Vacuous_truth) of
2865 * elements of empty collections.
2866 *
2867 * @static
2868 * @memberOf _
2869 * @since 0.1.0
2870 * @category Collection
2871 * @param {Array|Object} collection The collection to iterate over.
2872 * @param {Function} [predicate=_.identity] The function invoked per iteration.
2873 * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
2874 * @returns {boolean} Returns `true` if all elements pass the predicate check,
2875 * else `false`.
2876 * @example
2877 *
2878 * _.every([true, 1, null, 'yes'], Boolean);
2879 * // => false
2880 *
2881 * var users = [
2882 * { 'user': 'barney', 'age': 36, 'active': false },
2883 * { 'user': 'fred', 'age': 40, 'active': false }
2884 * ];
2885 *
2886 * // The `_.matches` iteratee shorthand.
2887 * _.every(users, { 'user': 'barney', 'active': false });
2888 * // => false
2889 *
2890 * // The `_.matchesProperty` iteratee shorthand.
2891 * _.every(users, ['active', false]);
2892 * // => true
2893 *
2894 * // The `_.property` iteratee shorthand.
2895 * _.every(users, 'active');
2896 * // => false
2897 */
2898 function every(collection, predicate, guard) {
2899 var func = (0,isArray/* default */.Z)(collection) ? _arrayEvery : _baseEvery;
2900 if (guard && (0,_isIterateeCall/* default */.Z)(collection, predicate, guard)) {
2901 predicate = undefined;
2902 }
2903 return func(collection, (0,_baseIteratee/* default */.Z)(predicate, 3));
2904 }
2905
2906 /* harmony default export */ const lodash_es_every = (every);
2907
2908 ;// CONCATENATED MODULE: ../node_modules/@chevrotain/gast/lib/src/helpers.js
2909
2910
2911 function isSequenceProd(prod) {
2912 return (prod instanceof Alternative ||
2913 prod instanceof Option ||
2914 prod instanceof Repetition ||
2915 prod instanceof RepetitionMandatory ||
2916 prod instanceof RepetitionMandatoryWithSeparator ||
2917 prod instanceof RepetitionWithSeparator ||
2918 prod instanceof Terminal ||
2919 prod instanceof Rule);
2920 }
2921 function isOptionalProd(prod, alreadyVisited = []) {
2922 const isDirectlyOptional = prod instanceof Option ||
2923 prod instanceof Repetition ||
2924 prod instanceof RepetitionWithSeparator;
2925 if (isDirectlyOptional) {
2926 return true;
2927 }
2928 // note that this can cause infinite loop if one optional empty TOP production has a cyclic dependency with another
2929 // empty optional top rule
2930 // may be indirectly optional ((A?B?C?) | (D?E?F?))
2931 if (prod instanceof Alternation) {
2932 // for OR its enough for just one of the alternatives to be optional
2933 return lodash_es_some(prod.definition, (subProd) => {
2934 return isOptionalProd(subProd, alreadyVisited);
2935 });
2936 }
2937 else if (prod instanceof NonTerminal && lodash_es_includes(alreadyVisited, prod)) {
2938 // avoiding stack overflow due to infinite recursion
2939 return false;
2940 }
2941 else if (prod instanceof AbstractProduction) {
2942 if (prod instanceof NonTerminal) {
2943 alreadyVisited.push(prod);
2944 }
2945 return lodash_es_every(prod.definition, (subProd) => {
2946 return isOptionalProd(subProd, alreadyVisited);
2947 });
2948 }
2949 else {
2950 return false;
2951 }
2952 }
2953 function isBranchingProd(prod) {
2954 return prod instanceof Alternation;
2955 }
2956 function getProductionDslName(prod) {
2957 /* istanbul ignore else */
2958 if (prod instanceof NonTerminal) {
2959 return "SUBRULE";
2960 }
2961 else if (prod instanceof Option) {
2962 return "OPTION";
2963 }
2964 else if (prod instanceof Alternation) {
2965 return "OR";
2966 }
2967 else if (prod instanceof RepetitionMandatory) {
2968 return "AT_LEAST_ONE";
2969 }
2970 else if (prod instanceof RepetitionMandatoryWithSeparator) {
2971 return "AT_LEAST_ONE_SEP";
2972 }
2973 else if (prod instanceof RepetitionWithSeparator) {
2974 return "MANY_SEP";
2975 }
2976 else if (prod instanceof Repetition) {
2977 return "MANY";
2978 }
2979 else if (prod instanceof Terminal) {
2980 return "CONSUME";
2981 /* c8 ignore next 3 */
2982 }
2983 else {
2984 throw Error("non exhaustive match");
2985 }
2986 }
2987 //# sourceMappingURL=helpers.js.map
2988 ;// CONCATENATED MODULE: ../node_modules/chevrotain/lib/src/parse/grammar/first.js
2989
2990
2991 function first(prod) {
2992 /* istanbul ignore else */
2993 if (prod instanceof NonTerminal) {
2994 // this could in theory cause infinite loops if
2995 // (1) prod A refs prod B.
2996 // (2) prod B refs prod A
2997 // (3) AB can match the empty set
2998 // in other words a cycle where everything is optional so the first will keep
2999 // looking ahead for the next optional part and will never exit
3000 // currently there is no safeguard for this unique edge case because
3001 // (1) not sure a grammar in which this can happen is useful for anything (productive)
3002 return first(prod.referencedRule);
3003 }
3004 else if (prod instanceof Terminal) {
3005 return firstForTerminal(prod);
3006 }
3007 else if (isSequenceProd(prod)) {
3008 return firstForSequence(prod);
3009 }
3010 else if (isBranchingProd(prod)) {
3011 return firstForBranching(prod);
3012 }
3013 else {
3014 throw Error("non exhaustive match");
3015 }
3016 }
3017 function firstForSequence(prod) {
3018 let firstSet = [];
3019 const seq = prod.definition;
3020 let nextSubProdIdx = 0;
3021 let hasInnerProdsRemaining = seq.length > nextSubProdIdx;
3022 let currSubProd;
3023 // so we enter the loop at least once (if the definition is not empty
3024 let isLastInnerProdOptional = true;
3025 // scan a sequence until it's end or until we have found a NONE optional production in it
3026 while (hasInnerProdsRemaining && isLastInnerProdOptional) {
3027 currSubProd = seq[nextSubProdIdx];
3028 isLastInnerProdOptional = isOptionalProd(currSubProd);
3029 firstSet = firstSet.concat(first(currSubProd));
3030 nextSubProdIdx = nextSubProdIdx + 1;
3031 hasInnerProdsRemaining = seq.length > nextSubProdIdx;
3032 }
3033 return lodash_es_uniq(firstSet);
3034 }
3035 function firstForBranching(prod) {
3036 const allAlternativesFirsts = (0,map/* default */.Z)(prod.definition, (innerProd) => {
3037 return first(innerProd);
3038 });
3039 return lodash_es_uniq((0,flatten/* default */.Z)(allAlternativesFirsts));
3040 }
3041 function firstForTerminal(terminal) {
3042 return [terminal.terminalType];
3043 }
3044 //# sourceMappingURL=first.js.map
3045 ;// CONCATENATED MODULE: ../node_modules/chevrotain/lib/src/parse/constants.js
3046 // TODO: can this be removed? where is it used?
3047 const constants_IN = "_~IN~_";
3048 //# sourceMappingURL=constants.js.map
3049 ;// CONCATENATED MODULE: ../node_modules/chevrotain/lib/src/parse/grammar/follow.js
3050
3051
3052
3053
3054
3055 // This ResyncFollowsWalker computes all of the follows required for RESYNC
3056 // (skipping reference production).
3057 class ResyncFollowsWalker extends RestWalker {
3058 constructor(topProd) {
3059 super();
3060 this.topProd = topProd;
3061 this.follows = {};
3062 }
3063 startWalking() {
3064 this.walk(this.topProd);
3065 return this.follows;
3066 }
3067 walkTerminal(terminal, currRest, prevRest) {
3068 // do nothing! just like in the public sector after 13:00
3069 }
3070 walkProdRef(refProd, currRest, prevRest) {
3071 const followName = buildBetweenProdsFollowPrefix(refProd.referencedRule, refProd.idx) +
3072 this.topProd.name;
3073 const fullRest = currRest.concat(prevRest);
3074 const restProd = new Alternative({ definition: fullRest });
3075 const t_in_topProd_follows = first(restProd);
3076 this.follows[followName] = t_in_topProd_follows;
3077 }
3078 }
3079 function computeAllProdsFollows(topProductions) {
3080 const reSyncFollows = {};
3081 (0,forEach/* default */.Z)(topProductions, (topProd) => {
3082 const currRefsFollow = new ResyncFollowsWalker(topProd).startWalking();
3083 lodash_es_assign(reSyncFollows, currRefsFollow);
3084 });
3085 return reSyncFollows;
3086 }
3087 function buildBetweenProdsFollowPrefix(inner, occurenceInParent) {
3088 return inner.name + occurenceInParent + constants_IN;
3089 }
3090 function buildInProdFollowPrefix(terminal) {
3091 const terminalName = terminal.terminalType.name;
3092 return terminalName + terminal.idx + IN;
3093 }
3094 //# sourceMappingURL=follow.js.map
3095 // EXTERNAL MODULE: ../node_modules/lodash-es/isUndefined.js
3096 var isUndefined = __webpack_require__(52307);
3097 // EXTERNAL MODULE: ../node_modules/@chevrotain/regexp-to-ast/lib/src/api.js + 4 modules
3098 var api = __webpack_require__(77647);
3099 // EXTERNAL MODULE: ../node_modules/lodash-es/defaults.js
3100 var defaults = __webpack_require__(65479);
3101 // EXTERNAL MODULE: ../node_modules/lodash-es/_arrayFilter.js
3102 var _arrayFilter = __webpack_require__(11819);
3103 // EXTERNAL MODULE: ../node_modules/lodash-es/_baseFilter.js
3104 var _baseFilter = __webpack_require__(45701);
3105 ;// CONCATENATED MODULE: ../node_modules/lodash-es/negate.js
3106 /** Error message constants. */
3107 var FUNC_ERROR_TEXT = 'Expected a function';
3108
3109 /**
3110 * Creates a function that negates the result of the predicate `func`. The
3111 * `func` predicate is invoked with the `this` binding and arguments of the
3112 * created function.
3113 *
3114 * @static
3115 * @memberOf _
3116 * @since 3.0.0
3117 * @category Function
3118 * @param {Function} predicate The predicate to negate.
3119 * @returns {Function} Returns the new negated function.
3120 * @example
3121 *
3122 * function isEven(n) {
3123 * return n % 2 == 0;
3124 * }
3125 *
3126 * _.filter([1, 2, 3, 4, 5, 6], _.negate(isEven));
3127 * // => [1, 3, 5]
3128 */
3129 function negate(predicate) {
3130 if (typeof predicate != 'function') {
3131 throw new TypeError(FUNC_ERROR_TEXT);
3132 }
3133 return function() {
3134 var args = arguments;
3135 switch (args.length) {
3136 case 0: return !predicate.call(this);
3137 case 1: return !predicate.call(this, args[0]);
3138 case 2: return !predicate.call(this, args[0], args[1]);
3139 case 3: return !predicate.call(this, args[0], args[1], args[2]);
3140 }
3141 return !predicate.apply(this, args);
3142 };
3143 }
3144
3145 /* harmony default export */ const lodash_es_negate = (negate);
3146
3147 ;// CONCATENATED MODULE: ../node_modules/lodash-es/reject.js
3148
3149
3150
3151
3152
3153
3154 /**
3155 * The opposite of `_.filter`; this method returns the elements of `collection`
3156 * that `predicate` does **not** return truthy for.
3157 *
3158 * @static
3159 * @memberOf _
3160 * @since 0.1.0
3161 * @category Collection
3162 * @param {Array|Object} collection The collection to iterate over.
3163 * @param {Function} [predicate=_.identity] The function invoked per iteration.
3164 * @returns {Array} Returns the new filtered array.
3165 * @see _.filter
3166 * @example
3167 *
3168 * var users = [
3169 * { 'user': 'barney', 'age': 36, 'active': false },
3170 * { 'user': 'fred', 'age': 40, 'active': true }
3171 * ];
3172 *
3173 * _.reject(users, function(o) { return !o.active; });
3174 * // => objects for ['fred']
3175 *
3176 * // The `_.matches` iteratee shorthand.
3177 * _.reject(users, { 'age': 40, 'active': true });
3178 * // => objects for ['barney']
3179 *
3180 * // The `_.matchesProperty` iteratee shorthand.
3181 * _.reject(users, ['active', false]);
3182 * // => objects for ['fred']
3183 *
3184 * // The `_.property` iteratee shorthand.
3185 * _.reject(users, 'active');
3186 * // => objects for ['barney']
3187 */
3188 function reject(collection, predicate) {
3189 var func = (0,isArray/* default */.Z)(collection) ? _arrayFilter/* default */.Z : _baseFilter/* default */.Z;
3190 return func(collection, lodash_es_negate((0,_baseIteratee/* default */.Z)(predicate, 3)));
3191 }
3192
3193 /* harmony default export */ const lodash_es_reject = (reject);
3194
3195 // EXTERNAL MODULE: ../node_modules/lodash-es/isFunction.js
3196 var isFunction = __webpack_require__(48489);
3197 ;// CONCATENATED MODULE: ../node_modules/lodash-es/indexOf.js
3198
3199
3200
3201 /* Built-in method references for those with the same name as other `lodash` methods. */
3202 var indexOf_nativeMax = Math.max;
3203
3204 /**
3205 * Gets the index at which the first occurrence of `value` is found in `array`
3206 * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
3207 * for equality comparisons. If `fromIndex` is negative, it's used as the
3208 * offset from the end of `array`.
3209 *
3210 * @static
3211 * @memberOf _
3212 * @since 0.1.0
3213 * @category Array
3214 * @param {Array} array The array to inspect.
3215 * @param {*} value The value to search for.
3216 * @param {number} [fromIndex=0] The index to search from.
3217 * @returns {number} Returns the index of the matched value, else `-1`.
3218 * @example
3219 *
3220 * _.indexOf([1, 2, 1, 2], 2);
3221 * // => 1
3222 *
3223 * // Search from the `fromIndex`.
3224 * _.indexOf([1, 2, 1, 2], 2, 2);
3225 * // => 3
3226 */
3227 function indexOf(array, value, fromIndex) {
3228 var length = array == null ? 0 : array.length;
3229 if (!length) {
3230 return -1;
3231 }
3232 var index = fromIndex == null ? 0 : (0,toInteger/* default */.Z)(fromIndex);
3233 if (index < 0) {
3234 index = indexOf_nativeMax(length + index, 0);
3235 }
3236 return (0,_baseIndexOf/* default */.Z)(array, value, index);
3237 }
3238
3239 /* harmony default export */ const lodash_es_indexOf = (indexOf);
3240
3241 // EXTERNAL MODULE: ../node_modules/lodash-es/reduce.js + 2 modules
3242 var reduce = __webpack_require__(99413);
3243 // EXTERNAL MODULE: ../node_modules/lodash-es/filter.js
3244 var filter = __webpack_require__(11382);
3245 // EXTERNAL MODULE: ../node_modules/lodash-es/_SetCache.js + 2 modules
3246 var _SetCache = __webpack_require__(40105);
3247 // EXTERNAL MODULE: ../node_modules/lodash-es/_arrayIncludes.js
3248 var _arrayIncludes = __webpack_require__(79036);
3249 // EXTERNAL MODULE: ../node_modules/lodash-es/_arrayIncludesWith.js
3250 var _arrayIncludesWith = __webpack_require__(58084);
3251 // EXTERNAL MODULE: ../node_modules/lodash-es/_cacheHas.js
3252 var _cacheHas = __webpack_require__(8142);
3253 ;// CONCATENATED MODULE: ../node_modules/lodash-es/_baseDifference.js
3254
3255
3256
3257
3258
3259
3260
3261 /** Used as the size to enable large array optimizations. */
3262 var LARGE_ARRAY_SIZE = 200;
3263
3264 /**
3265 * The base implementation of methods like `_.difference` without support
3266 * for excluding multiple arrays or iteratee shorthands.
3267 *
3268 * @private
3269 * @param {Array} array The array to inspect.
3270 * @param {Array} values The values to exclude.
3271 * @param {Function} [iteratee] The iteratee invoked per element.
3272 * @param {Function} [comparator] The comparator invoked per element.
3273 * @returns {Array} Returns the new array of filtered values.
3274 */
3275 function baseDifference(array, values, iteratee, comparator) {
3276 var index = -1,
3277 includes = _arrayIncludes/* default */.Z,
3278 isCommon = true,
3279 length = array.length,
3280 result = [],
3281 valuesLength = values.length;
3282
3283 if (!length) {
3284 return result;
3285 }
3286 if (iteratee) {
3287 values = (0,_arrayMap/* default */.Z)(values, (0,_baseUnary/* default */.Z)(iteratee));
3288 }
3289 if (comparator) {
3290 includes = _arrayIncludesWith/* default */.Z;
3291 isCommon = false;
3292 }
3293 else if (values.length >= LARGE_ARRAY_SIZE) {
3294 includes = _cacheHas/* default */.Z;
3295 isCommon = false;
3296 values = new _SetCache/* default */.Z(values);
3297 }
3298 outer:
3299 while (++index < length) {
3300 var value = array[index],
3301 computed = iteratee == null ? value : iteratee(value);
3302
3303 value = (comparator || value !== 0) ? value : 0;
3304 if (isCommon && computed === computed) {
3305 var valuesIndex = valuesLength;
3306 while (valuesIndex--) {
3307 if (values[valuesIndex] === computed) {
3308 continue outer;
3309 }
3310 }
3311 result.push(value);
3312 }
3313 else if (!includes(values, computed, comparator)) {
3314 result.push(value);
3315 }
3316 }
3317 return result;
3318 }
3319
3320 /* harmony default export */ const _baseDifference = (baseDifference);
3321
3322 // EXTERNAL MODULE: ../node_modules/lodash-es/_baseFlatten.js + 1 modules
3323 var _baseFlatten = __webpack_require__(65029);
3324 // EXTERNAL MODULE: ../node_modules/lodash-es/_baseRest.js
3325 var _baseRest = __webpack_require__(99719);
3326 // EXTERNAL MODULE: ../node_modules/lodash-es/isArrayLikeObject.js
3327 var isArrayLikeObject = __webpack_require__(60492);
3328 ;// CONCATENATED MODULE: ../node_modules/lodash-es/difference.js
3329
3330
3331
3332
3333
3334 /**
3335 * Creates an array of `array` values not included in the other given arrays
3336 * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
3337 * for equality comparisons. The order and references of result values are
3338 * determined by the first array.
3339 *
3340 * **Note:** Unlike `_.pullAll`, this method returns a new array.
3341 *
3342 * @static
3343 * @memberOf _
3344 * @since 0.1.0
3345 * @category Array
3346 * @param {Array} array The array to inspect.
3347 * @param {...Array} [values] The values to exclude.
3348 * @returns {Array} Returns the new array of filtered values.
3349 * @see _.without, _.xor
3350 * @example
3351 *
3352 * _.difference([2, 1], [2, 3]);
3353 * // => [1]
3354 */
3355 var difference = (0,_baseRest/* default */.Z)(function(array, values) {
3356 return (0,isArrayLikeObject/* default */.Z)(array)
3357 ? _baseDifference(array, (0,_baseFlatten/* default */.Z)(values, 1, isArrayLikeObject/* default */.Z, true))
3358 : [];
3359 });
3360
3361 /* harmony default export */ const lodash_es_difference = (difference);
3362
3363 ;// CONCATENATED MODULE: ../node_modules/lodash-es/compact.js
3364 /**
3365 * Creates an array with all falsey values removed. The values `false`, `null`,
3366 * `0`, `""`, `undefined`, and `NaN` are falsey.
3367 *
3368 * @static
3369 * @memberOf _
3370 * @since 0.1.0
3371 * @category Array
3372 * @param {Array} array The array to compact.
3373 * @returns {Array} Returns the new array of filtered values.
3374 * @example
3375 *
3376 * _.compact([0, 1, false, 2, '', 3]);
3377 * // => [1, 2, 3]
3378 */
3379 function compact(array) {
3380 var index = -1,
3381 length = array == null ? 0 : array.length,
3382 resIndex = 0,
3383 result = [];
3384
3385 while (++index < length) {
3386 var value = array[index];
3387 if (value) {
3388 result[resIndex++] = value;
3389 }
3390 }
3391 return result;
3392 }
3393
3394 /* harmony default export */ const lodash_es_compact = (compact);
3395
3396 ;// CONCATENATED MODULE: ../node_modules/lodash-es/head.js
3397 /**
3398 * Gets the first element of `array`.
3399 *
3400 * @static
3401 * @memberOf _
3402 * @since 0.1.0
3403 * @alias first
3404 * @category Array
3405 * @param {Array} array The array to query.
3406 * @returns {*} Returns the first element of `array`.
3407 * @example
3408 *
3409 * _.head([1, 2, 3]);
3410 * // => 1
3411 *
3412 * _.head([]);
3413 * // => undefined
3414 */
3415 function head(array) {
3416 return (array && array.length) ? array[0] : undefined;
3417 }
3418
3419 /* harmony default export */ const lodash_es_head = (head);
3420
3421 // EXTERNAL MODULE: ../node_modules/lodash-es/find.js + 2 modules
3422 var find = __webpack_require__(90970);
3423 ;// CONCATENATED MODULE: ../node_modules/@chevrotain/utils/lib/src/print.js
3424 function PRINT_ERROR(msg) {
3425 /* istanbul ignore else - can't override global.console in node.js */
3426 if (console && console.error) {
3427 console.error(`Error: ${msg}`);
3428 }
3429 }
3430 function PRINT_WARNING(msg) {
3431 /* istanbul ignore else - can't override global.console in node.js*/
3432 if (console && console.warn) {
3433 // TODO: modify docs accordingly
3434 console.warn(`Warning: ${msg}`);
3435 }
3436 }
3437 //# sourceMappingURL=print.js.map
3438 ;// CONCATENATED MODULE: ../node_modules/chevrotain/lib/src/scan/reg_exp_parser.js
3439
3440 let regExpAstCache = {};
3441 const regExpParser = new api/* RegExpParser */.O();
3442 function getRegExpAst(regExp) {
3443 const regExpStr = regExp.toString();
3444 if (regExpAstCache.hasOwnProperty(regExpStr)) {
3445 return regExpAstCache[regExpStr];
3446 }
3447 else {
3448 const regExpAst = regExpParser.pattern(regExpStr);
3449 regExpAstCache[regExpStr] = regExpAst;
3450 return regExpAst;
3451 }
3452 }
3453 function clearRegExpParserCache() {
3454 regExpAstCache = {};
3455 }
3456 //# sourceMappingURL=reg_exp_parser.js.map
3457 ;// CONCATENATED MODULE: ../node_modules/chevrotain/lib/src/scan/reg_exp.js
3458
3459
3460
3461
3462
3463 const complementErrorMessage = "Complement Sets are not supported for first char optimization";
3464 const failedOptimizationPrefixMsg = 'Unable to use "first char" lexer optimizations:\n';
3465 function getOptimizedStartCodesIndices(regExp, ensureOptimizations = false) {
3466 try {
3467 const ast = getRegExpAst(regExp);
3468 const firstChars = firstCharOptimizedIndices(ast.value, {}, ast.flags.ignoreCase);
3469 return firstChars;
3470 }
3471 catch (e) {
3472 /* istanbul ignore next */
3473 // Testing this relies on the regexp-to-ast library having a bug... */
3474 // TODO: only the else branch needs to be ignored, try to fix with newer prettier / tsc
3475 if (e.message === complementErrorMessage) {
3476 if (ensureOptimizations) {
3477 PRINT_WARNING(`${failedOptimizationPrefixMsg}` +
3478 `\tUnable to optimize: < ${regExp.toString()} >\n` +
3479 "\tComplement Sets cannot be automatically optimized.\n" +
3480 "\tThis will disable the lexer's first char optimizations.\n" +
3481 "\tSee: https://chevrotain.io/docs/guide/resolving_lexer_errors.html#COMPLEMENT for details.");
3482 }
3483 }
3484 else {
3485 let msgSuffix = "";
3486 if (ensureOptimizations) {
3487 msgSuffix =
3488 "\n\tThis will disable the lexer's first char optimizations.\n" +
3489 "\tSee: https://chevrotain.io/docs/guide/resolving_lexer_errors.html#REGEXP_PARSING for details.";
3490 }
3491 PRINT_ERROR(`${failedOptimizationPrefixMsg}\n` +
3492 `\tFailed parsing: < ${regExp.toString()} >\n` +
3493 `\tUsing the @chevrotain/regexp-to-ast library\n` +
3494 "\tPlease open an issue at: https://github.com/chevrotain/chevrotain/issues" +
3495 msgSuffix);
3496 }
3497 }
3498 return [];
3499 }
3500 function firstCharOptimizedIndices(ast, result, ignoreCase) {
3501 switch (ast.type) {
3502 case "Disjunction":
3503 for (let i = 0; i < ast.value.length; i++) {
3504 firstCharOptimizedIndices(ast.value[i], result, ignoreCase);
3505 }
3506 break;
3507 case "Alternative":
3508 const terms = ast.value;
3509 for (let i = 0; i < terms.length; i++) {
3510 const term = terms[i];
3511 // skip terms that cannot effect the first char results
3512 switch (term.type) {
3513 case "EndAnchor":
3514 // A group back reference cannot affect potential starting char.
3515 // because if a back reference is the first production than automatically
3516 // the group being referenced has had to come BEFORE so its codes have already been added
3517 case "GroupBackReference":
3518 // assertions do not affect potential starting codes
3519 case "Lookahead":
3520 case "NegativeLookahead":
3521 case "StartAnchor":
3522 case "WordBoundary":
3523 case "NonWordBoundary":
3524 continue;
3525 }
3526 const atom = term;
3527 switch (atom.type) {
3528 case "Character":
3529 addOptimizedIdxToResult(atom.value, result, ignoreCase);
3530 break;
3531 case "Set":
3532 if (atom.complement === true) {
3533 throw Error(complementErrorMessage);
3534 }
3535 (0,forEach/* default */.Z)(atom.value, (code) => {
3536 if (typeof code === "number") {
3537 addOptimizedIdxToResult(code, result, ignoreCase);
3538 }
3539 else {
3540 // range
3541 const range = code;
3542 // cannot optimize when ignoreCase is
3543 if (ignoreCase === true) {
3544 for (let rangeCode = range.from; rangeCode <= range.to; rangeCode++) {
3545 addOptimizedIdxToResult(rangeCode, result, ignoreCase);
3546 }
3547 }
3548 // Optimization (2 orders of magnitude less work for very large ranges)
3549 else {
3550 // handle unoptimized values
3551 for (let rangeCode = range.from; rangeCode <= range.to && rangeCode < minOptimizationVal; rangeCode++) {
3552 addOptimizedIdxToResult(rangeCode, result, ignoreCase);
3553 }
3554 // Less common charCode where we optimize for faster init time, by using larger "buckets"
3555 if (range.to >= minOptimizationVal) {
3556 const minUnOptVal = range.from >= minOptimizationVal
3557 ? range.from
3558 : minOptimizationVal;
3559 const maxUnOptVal = range.to;
3560 const minOptIdx = charCodeToOptimizedIndex(minUnOptVal);
3561 const maxOptIdx = charCodeToOptimizedIndex(maxUnOptVal);
3562 for (let currOptIdx = minOptIdx; currOptIdx <= maxOptIdx; currOptIdx++) {
3563 result[currOptIdx] = currOptIdx;
3564 }
3565 }
3566 }
3567 }
3568 });
3569 break;
3570 case "Group":
3571 firstCharOptimizedIndices(atom.value, result, ignoreCase);
3572 break;
3573 /* istanbul ignore next */
3574 default:
3575 throw Error("Non Exhaustive Match");
3576 }
3577 // reached a mandatory production, no more **start** codes can be found on this alternative
3578 const isOptionalQuantifier = atom.quantifier !== undefined && atom.quantifier.atLeast === 0;
3579 if (
3580 // A group may be optional due to empty contents /(?:)/
3581 // or if everything inside it is optional /((a)?)/
3582 (atom.type === "Group" && isWholeOptional(atom) === false) ||
3583 // If this term is not a group it may only be optional if it has an optional quantifier
3584 (atom.type !== "Group" && isOptionalQuantifier === false)) {
3585 break;
3586 }
3587 }
3588 break;
3589 /* istanbul ignore next */
3590 default:
3591 throw Error("non exhaustive match!");
3592 }
3593 // console.log(Object.keys(result).length)
3594 return (0,values/* default */.Z)(result);
3595 }
3596 function addOptimizedIdxToResult(code, result, ignoreCase) {
3597 const optimizedCharIdx = charCodeToOptimizedIndex(code);
3598 result[optimizedCharIdx] = optimizedCharIdx;
3599 if (ignoreCase === true) {
3600 handleIgnoreCase(code, result);
3601 }
3602 }
3603 function handleIgnoreCase(code, result) {
3604 const char = String.fromCharCode(code);
3605 const upperChar = char.toUpperCase();
3606 /* istanbul ignore else */
3607 if (upperChar !== char) {
3608 const optimizedCharIdx = charCodeToOptimizedIndex(upperChar.charCodeAt(0));
3609 result[optimizedCharIdx] = optimizedCharIdx;
3610 }
3611 else {
3612 const lowerChar = char.toLowerCase();
3613 if (lowerChar !== char) {
3614 const optimizedCharIdx = charCodeToOptimizedIndex(lowerChar.charCodeAt(0));
3615 result[optimizedCharIdx] = optimizedCharIdx;
3616 }
3617 }
3618 }
3619 function findCode(setNode, targetCharCodes) {
3620 return (0,find/* default */.Z)(setNode.value, (codeOrRange) => {
3621 if (typeof codeOrRange === "number") {
3622 return lodash_es_includes(targetCharCodes, codeOrRange);
3623 }
3624 else {
3625 // range
3626 const range = codeOrRange;
3627 return ((0,find/* default */.Z)(targetCharCodes, (targetCode) => range.from <= targetCode && targetCode <= range.to) !== undefined);
3628 }
3629 });
3630 }
3631 function isWholeOptional(ast) {
3632 const quantifier = ast.quantifier;
3633 if (quantifier && quantifier.atLeast === 0) {
3634 return true;
3635 }
3636 if (!ast.value) {
3637 return false;
3638 }
3639 return (0,isArray/* default */.Z)(ast.value)
3640 ? lodash_es_every(ast.value, isWholeOptional)
3641 : isWholeOptional(ast.value);
3642 }
3643 class CharCodeFinder extends api/* BaseRegExpVisitor */.e {
3644 constructor(targetCharCodes) {
3645 super();
3646 this.targetCharCodes = targetCharCodes;
3647 this.found = false;
3648 }
3649 visitChildren(node) {
3650 // No need to keep looking...
3651 if (this.found === true) {
3652 return;
3653 }
3654 // switch lookaheads as they do not actually consume any characters thus
3655 // finding a charCode at lookahead context does not mean that regexp can actually contain it in a match.
3656 switch (node.type) {
3657 case "Lookahead":
3658 this.visitLookahead(node);
3659 return;
3660 case "NegativeLookahead":
3661 this.visitNegativeLookahead(node);
3662 return;
3663 }
3664 super.visitChildren(node);
3665 }
3666 visitCharacter(node) {
3667 if (lodash_es_includes(this.targetCharCodes, node.value)) {
3668 this.found = true;
3669 }
3670 }
3671 visitSet(node) {
3672 if (node.complement) {
3673 if (findCode(node, this.targetCharCodes) === undefined) {
3674 this.found = true;
3675 }
3676 }
3677 else {
3678 if (findCode(node, this.targetCharCodes) !== undefined) {
3679 this.found = true;
3680 }
3681 }
3682 }
3683 }
3684 function canMatchCharCode(charCodes, pattern) {
3685 if (pattern instanceof RegExp) {
3686 const ast = getRegExpAst(pattern);
3687 const charCodeFinder = new CharCodeFinder(charCodes);
3688 charCodeFinder.visit(ast);
3689 return charCodeFinder.found;
3690 }
3691 else {
3692 return ((0,find/* default */.Z)(pattern, (char) => {
3693 return lodash_es_includes(charCodes, char.charCodeAt(0));
3694 }) !== undefined);
3695 }
3696 }
3697 //# sourceMappingURL=reg_exp.js.map
3698 ;// CONCATENATED MODULE: ../node_modules/chevrotain/lib/src/scan/lexer.js
3699
3700
3701
3702
3703
3704
3705 const PATTERN = "PATTERN";
3706 const DEFAULT_MODE = "defaultMode";
3707 const MODES = "modes";
3708 let SUPPORT_STICKY = typeof new RegExp("(?:)").sticky === "boolean";
3709 function disableSticky() {
3710 SUPPORT_STICKY = false;
3711 }
3712 function enableSticky() {
3713 SUPPORT_STICKY = true;
3714 }
3715 function analyzeTokenTypes(tokenTypes, options) {
3716 options = (0,defaults/* default */.Z)(options, {
3717 useSticky: SUPPORT_STICKY,
3718 debug: false,
3719 safeMode: false,
3720 positionTracking: "full",
3721 lineTerminatorCharacters: ["\r", "\n"],
3722 tracer: (msg, action) => action(),
3723 });
3724 const tracer = options.tracer;
3725 tracer("initCharCodeToOptimizedIndexMap", () => {
3726 initCharCodeToOptimizedIndexMap();
3727 });
3728 let onlyRelevantTypes;
3729 tracer("Reject Lexer.NA", () => {
3730 onlyRelevantTypes = lodash_es_reject(tokenTypes, (currType) => {
3731 return currType[PATTERN] === Lexer.NA;
3732 });
3733 });
3734 let hasCustom = false;
3735 let allTransformedPatterns;
3736 tracer("Transform Patterns", () => {
3737 hasCustom = false;
3738 allTransformedPatterns = (0,map/* default */.Z)(onlyRelevantTypes, (currType) => {
3739 const currPattern = currType[PATTERN];
3740 /* istanbul ignore else */
3741 if (lodash_es_isRegExp(currPattern)) {
3742 const regExpSource = currPattern.source;
3743 if (regExpSource.length === 1 &&
3744 // only these regExp meta characters which can appear in a length one regExp
3745 regExpSource !== "^" &&
3746 regExpSource !== "$" &&
3747 regExpSource !== "." &&
3748 !currPattern.ignoreCase) {
3749 return regExpSource;
3750 }
3751 else if (regExpSource.length === 2 &&
3752 regExpSource[0] === "\\" &&
3753 // not a meta character
3754 !lodash_es_includes([
3755 "d",
3756 "D",
3757 "s",
3758 "S",
3759 "t",
3760 "r",
3761 "n",
3762 "t",
3763 "0",
3764 "c",
3765 "b",
3766 "B",
3767 "f",
3768 "v",
3769 "w",
3770 "W",
3771 ], regExpSource[1])) {
3772 // escaped meta Characters: /\+/ /\[/
3773 // or redundant escaping: /\a/
3774 // without the escaping "\"
3775 return regExpSource[1];
3776 }
3777 else {
3778 return options.useSticky
3779 ? addStickyFlag(currPattern)
3780 : addStartOfInput(currPattern);
3781 }
3782 }
3783 else if ((0,isFunction/* default */.Z)(currPattern)) {
3784 hasCustom = true;
3785 // CustomPatternMatcherFunc - custom patterns do not require any transformations, only wrapping in a RegExp Like object
3786 return { exec: currPattern };
3787 }
3788 else if (typeof currPattern === "object") {
3789 hasCustom = true;
3790 // ICustomPattern
3791 return currPattern;
3792 }
3793 else if (typeof currPattern === "string") {
3794 if (currPattern.length === 1) {
3795 return currPattern;
3796 }
3797 else {
3798 const escapedRegExpString = currPattern.replace(/[\\^$.*+?()[\]{}|]/g, "\\$&");
3799 const wrappedRegExp = new RegExp(escapedRegExpString);
3800 return options.useSticky
3801 ? addStickyFlag(wrappedRegExp)
3802 : addStartOfInput(wrappedRegExp);
3803 }
3804 }
3805 else {
3806 throw Error("non exhaustive match");
3807 }
3808 });
3809 });
3810 let patternIdxToType;
3811 let patternIdxToGroup;
3812 let patternIdxToLongerAltIdxArr;
3813 let patternIdxToPushMode;
3814 let patternIdxToPopMode;
3815 tracer("misc mapping", () => {
3816 patternIdxToType = (0,map/* default */.Z)(onlyRelevantTypes, (currType) => currType.tokenTypeIdx);
3817 patternIdxToGroup = (0,map/* default */.Z)(onlyRelevantTypes, (clazz) => {
3818 const groupName = clazz.GROUP;
3819 /* istanbul ignore next */
3820 if (groupName === Lexer.SKIPPED) {
3821 return undefined;
3822 }
3823 else if ((0,isString/* default */.Z)(groupName)) {
3824 return groupName;
3825 }
3826 else if ((0,isUndefined/* default */.Z)(groupName)) {
3827 return false;
3828 }
3829 else {
3830 throw Error("non exhaustive match");
3831 }
3832 });
3833 patternIdxToLongerAltIdxArr = (0,map/* default */.Z)(onlyRelevantTypes, (clazz) => {
3834 const longerAltType = clazz.LONGER_ALT;
3835 if (longerAltType) {
3836 const longerAltIdxArr = (0,isArray/* default */.Z)(longerAltType)
3837 ? (0,map/* default */.Z)(longerAltType, (type) => lodash_es_indexOf(onlyRelevantTypes, type))
3838 : [lodash_es_indexOf(onlyRelevantTypes, longerAltType)];
3839 return longerAltIdxArr;
3840 }
3841 });
3842 patternIdxToPushMode = (0,map/* default */.Z)(onlyRelevantTypes, (clazz) => clazz.PUSH_MODE);
3843 patternIdxToPopMode = (0,map/* default */.Z)(onlyRelevantTypes, (clazz) => (0,has/* default */.Z)(clazz, "POP_MODE"));
3844 });
3845 let patternIdxToCanLineTerminator;
3846 tracer("Line Terminator Handling", () => {
3847 const lineTerminatorCharCodes = getCharCodes(options.lineTerminatorCharacters);
3848 patternIdxToCanLineTerminator = (0,map/* default */.Z)(onlyRelevantTypes, (tokType) => false);
3849 if (options.positionTracking !== "onlyOffset") {
3850 patternIdxToCanLineTerminator = (0,map/* default */.Z)(onlyRelevantTypes, (tokType) => {
3851 if ((0,has/* default */.Z)(tokType, "LINE_BREAKS")) {
3852 return !!tokType.LINE_BREAKS;
3853 }
3854 else {
3855 return (checkLineBreaksIssues(tokType, lineTerminatorCharCodes) === false &&
3856 canMatchCharCode(lineTerminatorCharCodes, tokType.PATTERN));
3857 }
3858 });
3859 }
3860 });
3861 let patternIdxToIsCustom;
3862 let patternIdxToShort;
3863 let emptyGroups;
3864 let patternIdxToConfig;
3865 tracer("Misc Mapping #2", () => {
3866 patternIdxToIsCustom = (0,map/* default */.Z)(onlyRelevantTypes, isCustomPattern);
3867 patternIdxToShort = (0,map/* default */.Z)(allTransformedPatterns, isShortPattern);
3868 emptyGroups = (0,reduce/* default */.Z)(onlyRelevantTypes, (acc, clazz) => {
3869 const groupName = clazz.GROUP;
3870 if ((0,isString/* default */.Z)(groupName) && !(groupName === Lexer.SKIPPED)) {
3871 acc[groupName] = [];
3872 }
3873 return acc;
3874 }, {});
3875 patternIdxToConfig = (0,map/* default */.Z)(allTransformedPatterns, (x, idx) => {
3876 return {
3877 pattern: allTransformedPatterns[idx],
3878 longerAlt: patternIdxToLongerAltIdxArr[idx],
3879 canLineTerminator: patternIdxToCanLineTerminator[idx],
3880 isCustom: patternIdxToIsCustom[idx],
3881 short: patternIdxToShort[idx],
3882 group: patternIdxToGroup[idx],
3883 push: patternIdxToPushMode[idx],
3884 pop: patternIdxToPopMode[idx],
3885 tokenTypeIdx: patternIdxToType[idx],
3886 tokenType: onlyRelevantTypes[idx],
3887 };
3888 });
3889 });
3890 let canBeOptimized = true;
3891 let charCodeToPatternIdxToConfig = [];
3892 if (!options.safeMode) {
3893 tracer("First Char Optimization", () => {
3894 charCodeToPatternIdxToConfig = (0,reduce/* default */.Z)(onlyRelevantTypes, (result, currTokType, idx) => {
3895 if (typeof currTokType.PATTERN === "string") {
3896 const charCode = currTokType.PATTERN.charCodeAt(0);
3897 const optimizedIdx = charCodeToOptimizedIndex(charCode);
3898 addToMapOfArrays(result, optimizedIdx, patternIdxToConfig[idx]);
3899 }
3900 else if ((0,isArray/* default */.Z)(currTokType.START_CHARS_HINT)) {
3901 let lastOptimizedIdx;
3902 (0,forEach/* default */.Z)(currTokType.START_CHARS_HINT, (charOrInt) => {
3903 const charCode = typeof charOrInt === "string"
3904 ? charOrInt.charCodeAt(0)
3905 : charOrInt;
3906 const currOptimizedIdx = charCodeToOptimizedIndex(charCode);
3907 // Avoid adding the config multiple times
3908 /* istanbul ignore else */
3909 // - Difficult to check this scenario effects as it is only a performance
3910 // optimization that does not change correctness
3911 if (lastOptimizedIdx !== currOptimizedIdx) {
3912 lastOptimizedIdx = currOptimizedIdx;
3913 addToMapOfArrays(result, currOptimizedIdx, patternIdxToConfig[idx]);
3914 }
3915 });
3916 }
3917 else if (lodash_es_isRegExp(currTokType.PATTERN)) {
3918 if (currTokType.PATTERN.unicode) {
3919 canBeOptimized = false;
3920 if (options.ensureOptimizations) {
3921 PRINT_ERROR(`${failedOptimizationPrefixMsg}` +
3922 `\tUnable to analyze < ${currTokType.PATTERN.toString()} > pattern.\n` +
3923 "\tThe regexp unicode flag is not currently supported by the regexp-to-ast library.\n" +
3924 "\tThis will disable the lexer's first char optimizations.\n" +
3925 "\tFor details See: https://chevrotain.io/docs/guide/resolving_lexer_errors.html#UNICODE_OPTIMIZE");
3926 }
3927 }
3928 else {
3929 const optimizedCodes = getOptimizedStartCodesIndices(currTokType.PATTERN, options.ensureOptimizations);
3930 /* istanbul ignore if */
3931 // start code will only be empty given an empty regExp or failure of regexp-to-ast library
3932 // the first should be a different validation and the second cannot be tested.
3933 if ((0,isEmpty/* default */.Z)(optimizedCodes)) {
3934 // we cannot understand what codes may start possible matches
3935 // The optimization correctness requires knowing start codes for ALL patterns.
3936 // Not actually sure this is an error, no debug message
3937 canBeOptimized = false;
3938 }
3939 (0,forEach/* default */.Z)(optimizedCodes, (code) => {
3940 addToMapOfArrays(result, code, patternIdxToConfig[idx]);
3941 });
3942 }
3943 }
3944 else {
3945 if (options.ensureOptimizations) {
3946 PRINT_ERROR(`${failedOptimizationPrefixMsg}` +
3947 `\tTokenType: <${currTokType.name}> is using a custom token pattern without providing <start_chars_hint> parameter.\n` +
3948 "\tThis will disable the lexer's first char optimizations.\n" +
3949 "\tFor details See: https://chevrotain.io/docs/guide/resolving_lexer_errors.html#CUSTOM_OPTIMIZE");
3950 }
3951 canBeOptimized = false;
3952 }
3953 return result;
3954 }, []);
3955 });
3956 }
3957 return {
3958 emptyGroups: emptyGroups,
3959 patternIdxToConfig: patternIdxToConfig,
3960 charCodeToPatternIdxToConfig: charCodeToPatternIdxToConfig,
3961 hasCustom: hasCustom,
3962 canBeOptimized: canBeOptimized,
3963 };
3964 }
3965 function validatePatterns(tokenTypes, validModesNames) {
3966 let errors = [];
3967 const missingResult = findMissingPatterns(tokenTypes);
3968 errors = errors.concat(missingResult.errors);
3969 const invalidResult = findInvalidPatterns(missingResult.valid);
3970 const validTokenTypes = invalidResult.valid;
3971 errors = errors.concat(invalidResult.errors);
3972 errors = errors.concat(validateRegExpPattern(validTokenTypes));
3973 errors = errors.concat(findInvalidGroupType(validTokenTypes));
3974 errors = errors.concat(findModesThatDoNotExist(validTokenTypes, validModesNames));
3975 errors = errors.concat(findUnreachablePatterns(validTokenTypes));
3976 return errors;
3977 }
3978 function validateRegExpPattern(tokenTypes) {
3979 let errors = [];
3980 const withRegExpPatterns = (0,filter/* default */.Z)(tokenTypes, (currTokType) => lodash_es_isRegExp(currTokType[PATTERN]));
3981 errors = errors.concat(findEndOfInputAnchor(withRegExpPatterns));
3982 errors = errors.concat(findStartOfInputAnchor(withRegExpPatterns));
3983 errors = errors.concat(findUnsupportedFlags(withRegExpPatterns));
3984 errors = errors.concat(findDuplicatePatterns(withRegExpPatterns));
3985 errors = errors.concat(findEmptyMatchRegExps(withRegExpPatterns));
3986 return errors;
3987 }
3988 function findMissingPatterns(tokenTypes) {
3989 const tokenTypesWithMissingPattern = (0,filter/* default */.Z)(tokenTypes, (currType) => {
3990 return !(0,has/* default */.Z)(currType, PATTERN);
3991 });
3992 const errors = (0,map/* default */.Z)(tokenTypesWithMissingPattern, (currType) => {
3993 return {
3994 message: "Token Type: ->" +
3995 currType.name +
3996 "<- missing static 'PATTERN' property",
3997 type: LexerDefinitionErrorType.MISSING_PATTERN,
3998 tokenTypes: [currType],
3999 };
4000 });
4001 const valid = lodash_es_difference(tokenTypes, tokenTypesWithMissingPattern);
4002 return { errors, valid };
4003 }
4004 function findInvalidPatterns(tokenTypes) {
4005 const tokenTypesWithInvalidPattern = (0,filter/* default */.Z)(tokenTypes, (currType) => {
4006 const pattern = currType[PATTERN];
4007 return (!lodash_es_isRegExp(pattern) &&
4008 !(0,isFunction/* default */.Z)(pattern) &&
4009 !(0,has/* default */.Z)(pattern, "exec") &&
4010 !(0,isString/* default */.Z)(pattern));
4011 });
4012 const errors = (0,map/* default */.Z)(tokenTypesWithInvalidPattern, (currType) => {
4013 return {
4014 message: "Token Type: ->" +
4015 currType.name +
4016 "<- static 'PATTERN' can only be a RegExp, a" +
4017 " Function matching the {CustomPatternMatcherFunc} type or an Object matching the {ICustomPattern} interface.",
4018 type: LexerDefinitionErrorType.INVALID_PATTERN,
4019 tokenTypes: [currType],
4020 };
4021 });
4022 const valid = lodash_es_difference(tokenTypes, tokenTypesWithInvalidPattern);
4023 return { errors, valid };
4024 }
4025 const end_of_input = /[^\\][$]/;
4026 function findEndOfInputAnchor(tokenTypes) {
4027 class EndAnchorFinder extends api/* BaseRegExpVisitor */.e {
4028 constructor() {
4029 super(...arguments);
4030 this.found = false;
4031 }
4032 visitEndAnchor(node) {
4033 this.found = true;
4034 }
4035 }
4036 const invalidRegex = (0,filter/* default */.Z)(tokenTypes, (currType) => {
4037 const pattern = currType.PATTERN;
4038 try {
4039 const regexpAst = getRegExpAst(pattern);
4040 const endAnchorVisitor = new EndAnchorFinder();
4041 endAnchorVisitor.visit(regexpAst);
4042 return endAnchorVisitor.found;
4043 }
4044 catch (e) {
4045 // old behavior in case of runtime exceptions with regexp-to-ast.
4046 /* istanbul ignore next - cannot ensure an error in regexp-to-ast*/
4047 return end_of_input.test(pattern.source);
4048 }
4049 });
4050 const errors = (0,map/* default */.Z)(invalidRegex, (currType) => {
4051 return {
4052 message: "Unexpected RegExp Anchor Error:\n" +
4053 "\tToken Type: ->" +
4054 currType.name +
4055 "<- static 'PATTERN' cannot contain end of input anchor '$'\n" +
4056 "\tSee chevrotain.io/docs/guide/resolving_lexer_errors.html#ANCHORS" +
4057 "\tfor details.",
4058 type: LexerDefinitionErrorType.EOI_ANCHOR_FOUND,
4059 tokenTypes: [currType],
4060 };
4061 });
4062 return errors;
4063 }
4064 function findEmptyMatchRegExps(tokenTypes) {
4065 const matchesEmptyString = (0,filter/* default */.Z)(tokenTypes, (currType) => {
4066 const pattern = currType.PATTERN;
4067 return pattern.test("");
4068 });
4069 const errors = (0,map/* default */.Z)(matchesEmptyString, (currType) => {
4070 return {
4071 message: "Token Type: ->" +
4072 currType.name +
4073 "<- static 'PATTERN' must not match an empty string",
4074 type: LexerDefinitionErrorType.EMPTY_MATCH_PATTERN,
4075 tokenTypes: [currType],
4076 };
4077 });
4078 return errors;
4079 }
4080 const start_of_input = /[^\\[][\^]|^\^/;
4081 function findStartOfInputAnchor(tokenTypes) {
4082 class StartAnchorFinder extends api/* BaseRegExpVisitor */.e {
4083 constructor() {
4084 super(...arguments);
4085 this.found = false;
4086 }
4087 visitStartAnchor(node) {
4088 this.found = true;
4089 }
4090 }
4091 const invalidRegex = (0,filter/* default */.Z)(tokenTypes, (currType) => {
4092 const pattern = currType.PATTERN;
4093 try {
4094 const regexpAst = getRegExpAst(pattern);
4095 const startAnchorVisitor = new StartAnchorFinder();
4096 startAnchorVisitor.visit(regexpAst);
4097 return startAnchorVisitor.found;
4098 }
4099 catch (e) {
4100 // old behavior in case of runtime exceptions with regexp-to-ast.
4101 /* istanbul ignore next - cannot ensure an error in regexp-to-ast*/
4102 return start_of_input.test(pattern.source);
4103 }
4104 });
4105 const errors = (0,map/* default */.Z)(invalidRegex, (currType) => {
4106 return {
4107 message: "Unexpected RegExp Anchor Error:\n" +
4108 "\tToken Type: ->" +
4109 currType.name +
4110 "<- static 'PATTERN' cannot contain start of input anchor '^'\n" +
4111 "\tSee https://chevrotain.io/docs/guide/resolving_lexer_errors.html#ANCHORS" +
4112 "\tfor details.",
4113 type: LexerDefinitionErrorType.SOI_ANCHOR_FOUND,
4114 tokenTypes: [currType],
4115 };
4116 });
4117 return errors;
4118 }
4119 function findUnsupportedFlags(tokenTypes) {
4120 const invalidFlags = (0,filter/* default */.Z)(tokenTypes, (currType) => {
4121 const pattern = currType[PATTERN];
4122 return pattern instanceof RegExp && (pattern.multiline || pattern.global);
4123 });
4124 const errors = (0,map/* default */.Z)(invalidFlags, (currType) => {
4125 return {
4126 message: "Token Type: ->" +
4127 currType.name +
4128 "<- static 'PATTERN' may NOT contain global('g') or multiline('m')",
4129 type: LexerDefinitionErrorType.UNSUPPORTED_FLAGS_FOUND,
4130 tokenTypes: [currType],
4131 };
4132 });
4133 return errors;
4134 }
4135 // This can only test for identical duplicate RegExps, not semantically equivalent ones.
4136 function findDuplicatePatterns(tokenTypes) {
4137 const found = [];
4138 let identicalPatterns = (0,map/* default */.Z)(tokenTypes, (outerType) => {
4139 return (0,reduce/* default */.Z)(tokenTypes, (result, innerType) => {
4140 if (outerType.PATTERN.source === innerType.PATTERN.source &&
4141 !lodash_es_includes(found, innerType) &&
4142 innerType.PATTERN !== Lexer.NA) {
4143 // this avoids duplicates in the result, each Token Type may only appear in one "set"
4144 // in essence we are creating Equivalence classes on equality relation.
4145 found.push(innerType);
4146 result.push(innerType);
4147 return result;
4148 }
4149 return result;
4150 }, []);
4151 });
4152 identicalPatterns = lodash_es_compact(identicalPatterns);
4153 const duplicatePatterns = (0,filter/* default */.Z)(identicalPatterns, (currIdenticalSet) => {
4154 return currIdenticalSet.length > 1;
4155 });
4156 const errors = (0,map/* default */.Z)(duplicatePatterns, (setOfIdentical) => {
4157 const tokenTypeNames = (0,map/* default */.Z)(setOfIdentical, (currType) => {
4158 return currType.name;
4159 });
4160 const dupPatternSrc = lodash_es_head(setOfIdentical).PATTERN;
4161 return {
4162 message: `The same RegExp pattern ->${dupPatternSrc}<-` +
4163 `has been used in all of the following Token Types: ${tokenTypeNames.join(", ")} <-`,
4164 type: LexerDefinitionErrorType.DUPLICATE_PATTERNS_FOUND,
4165 tokenTypes: setOfIdentical,
4166 };
4167 });
4168 return errors;
4169 }
4170 function findInvalidGroupType(tokenTypes) {
4171 const invalidTypes = (0,filter/* default */.Z)(tokenTypes, (clazz) => {
4172 if (!(0,has/* default */.Z)(clazz, "GROUP")) {
4173 return false;
4174 }
4175 const group = clazz.GROUP;
4176 return group !== Lexer.SKIPPED && group !== Lexer.NA && !(0,isString/* default */.Z)(group);
4177 });
4178 const errors = (0,map/* default */.Z)(invalidTypes, (currType) => {
4179 return {
4180 message: "Token Type: ->" +
4181 currType.name +
4182 "<- static 'GROUP' can only be Lexer.SKIPPED/Lexer.NA/A String",
4183 type: LexerDefinitionErrorType.INVALID_GROUP_TYPE_FOUND,
4184 tokenTypes: [currType],
4185 };
4186 });
4187 return errors;
4188 }
4189 function findModesThatDoNotExist(tokenTypes, validModes) {
4190 const invalidModes = (0,filter/* default */.Z)(tokenTypes, (clazz) => {
4191 return (clazz.PUSH_MODE !== undefined && !lodash_es_includes(validModes, clazz.PUSH_MODE));
4192 });
4193 const errors = (0,map/* default */.Z)(invalidModes, (tokType) => {
4194 const msg = `Token Type: ->${tokType.name}<- static 'PUSH_MODE' value cannot refer to a Lexer Mode ->${tokType.PUSH_MODE}<-` +
4195 `which does not exist`;
4196 return {
4197 message: msg,
4198 type: LexerDefinitionErrorType.PUSH_MODE_DOES_NOT_EXIST,
4199 tokenTypes: [tokType],
4200 };
4201 });
4202 return errors;
4203 }
4204 function findUnreachablePatterns(tokenTypes) {
4205 const errors = [];
4206 const canBeTested = (0,reduce/* default */.Z)(tokenTypes, (result, tokType, idx) => {
4207 const pattern = tokType.PATTERN;
4208 if (pattern === Lexer.NA) {
4209 return result;
4210 }
4211 // a more comprehensive validation for all forms of regExps would require
4212 // deeper regExp analysis capabilities
4213 if ((0,isString/* default */.Z)(pattern)) {
4214 result.push({ str: pattern, idx, tokenType: tokType });
4215 }
4216 else if (lodash_es_isRegExp(pattern) && noMetaChar(pattern)) {
4217 result.push({ str: pattern.source, idx, tokenType: tokType });
4218 }
4219 return result;
4220 }, []);
4221 (0,forEach/* default */.Z)(tokenTypes, (tokType, testIdx) => {
4222 (0,forEach/* default */.Z)(canBeTested, ({ str, idx, tokenType }) => {
4223 if (testIdx < idx && testTokenType(str, tokType.PATTERN)) {
4224 const msg = `Token: ->${tokenType.name}<- can never be matched.\n` +
4225 `Because it appears AFTER the Token Type ->${tokType.name}<-` +
4226 `in the lexer's definition.\n` +
4227 `See https://chevrotain.io/docs/guide/resolving_lexer_errors.html#UNREACHABLE`;
4228 errors.push({
4229 message: msg,
4230 type: LexerDefinitionErrorType.UNREACHABLE_PATTERN,
4231 tokenTypes: [tokType, tokenType],
4232 });
4233 }
4234 });
4235 });
4236 return errors;
4237 }
4238 function testTokenType(str, pattern) {
4239 /* istanbul ignore else */
4240 if (lodash_es_isRegExp(pattern)) {
4241 const regExpArray = pattern.exec(str);
4242 return regExpArray !== null && regExpArray.index === 0;
4243 }
4244 else if ((0,isFunction/* default */.Z)(pattern)) {
4245 // maintain the API of custom patterns
4246 return pattern(str, 0, [], {});
4247 }
4248 else if ((0,has/* default */.Z)(pattern, "exec")) {
4249 // maintain the API of custom patterns
4250 return pattern.exec(str, 0, [], {});
4251 }
4252 else if (typeof pattern === "string") {
4253 return pattern === str;
4254 }
4255 else {
4256 throw Error("non exhaustive match");
4257 }
4258 }
4259 function noMetaChar(regExp) {
4260 //https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp
4261 const metaChars = [
4262 ".",
4263 "\\",
4264 "[",
4265 "]",
4266 "|",
4267 "^",
4268 "$",
4269 "(",
4270 ")",
4271 "?",
4272 "*",
4273 "+",
4274 "{",
4275 ];
4276 return ((0,find/* default */.Z)(metaChars, (char) => regExp.source.indexOf(char) !== -1) === undefined);
4277 }
4278 function addStartOfInput(pattern) {
4279 const flags = pattern.ignoreCase ? "i" : "";
4280 // always wrapping in a none capturing group preceded by '^' to make sure matching can only work on start of input.
4281 // duplicate/redundant start of input markers have no meaning (/^^^^A/ === /^A/)
4282 return new RegExp(`^(?:${pattern.source})`, flags);
4283 }
4284 function addStickyFlag(pattern) {
4285 const flags = pattern.ignoreCase ? "iy" : "y";
4286 // always wrapping in a none capturing group preceded by '^' to make sure matching can only work on start of input.
4287 // duplicate/redundant start of input markers have no meaning (/^^^^A/ === /^A/)
4288 return new RegExp(`${pattern.source}`, flags);
4289 }
4290 function performRuntimeChecks(lexerDefinition, trackLines, lineTerminatorCharacters) {
4291 const errors = [];
4292 // some run time checks to help the end users.
4293 if (!(0,has/* default */.Z)(lexerDefinition, DEFAULT_MODE)) {
4294 errors.push({
4295 message: "A MultiMode Lexer cannot be initialized without a <" +
4296 DEFAULT_MODE +
4297 "> property in its definition\n",
4298 type: LexerDefinitionErrorType.MULTI_MODE_LEXER_WITHOUT_DEFAULT_MODE,
4299 });
4300 }
4301 if (!(0,has/* default */.Z)(lexerDefinition, MODES)) {
4302 errors.push({
4303 message: "A MultiMode Lexer cannot be initialized without a <" +
4304 MODES +
4305 "> property in its definition\n",
4306 type: LexerDefinitionErrorType.MULTI_MODE_LEXER_WITHOUT_MODES_PROPERTY,
4307 });
4308 }
4309 if ((0,has/* default */.Z)(lexerDefinition, MODES) &&
4310 (0,has/* default */.Z)(lexerDefinition, DEFAULT_MODE) &&
4311 !(0,has/* default */.Z)(lexerDefinition.modes, lexerDefinition.defaultMode)) {
4312 errors.push({
4313 message: `A MultiMode Lexer cannot be initialized with a ${DEFAULT_MODE}: <${lexerDefinition.defaultMode}>` +
4314 `which does not exist\n`,
4315 type: LexerDefinitionErrorType.MULTI_MODE_LEXER_DEFAULT_MODE_VALUE_DOES_NOT_EXIST,
4316 });
4317 }
4318 if ((0,has/* default */.Z)(lexerDefinition, MODES)) {
4319 (0,forEach/* default */.Z)(lexerDefinition.modes, (currModeValue, currModeName) => {
4320 (0,forEach/* default */.Z)(currModeValue, (currTokType, currIdx) => {
4321 if ((0,isUndefined/* default */.Z)(currTokType)) {
4322 errors.push({
4323 message: `A Lexer cannot be initialized using an undefined Token Type. Mode:` +
4324 `<${currModeName}> at index: <${currIdx}>\n`,
4325 type: LexerDefinitionErrorType.LEXER_DEFINITION_CANNOT_CONTAIN_UNDEFINED,
4326 });
4327 }
4328 else if ((0,has/* default */.Z)(currTokType, "LONGER_ALT")) {
4329 const longerAlt = (0,isArray/* default */.Z)(currTokType.LONGER_ALT)
4330 ? currTokType.LONGER_ALT
4331 : [currTokType.LONGER_ALT];
4332 (0,forEach/* default */.Z)(longerAlt, (currLongerAlt) => {
4333 if (!(0,isUndefined/* default */.Z)(currLongerAlt) &&
4334 !lodash_es_includes(currModeValue, currLongerAlt)) {
4335 errors.push({
4336 message: `A MultiMode Lexer cannot be initialized with a longer_alt <${currLongerAlt.name}> on token <${currTokType.name}> outside of mode <${currModeName}>\n`,
4337 type: LexerDefinitionErrorType.MULTI_MODE_LEXER_LONGER_ALT_NOT_IN_CURRENT_MODE,
4338 });
4339 }
4340 });
4341 }
4342 });
4343 });
4344 }
4345 return errors;
4346 }
4347 function performWarningRuntimeChecks(lexerDefinition, trackLines, lineTerminatorCharacters) {
4348 const warnings = [];
4349 let hasAnyLineBreak = false;
4350 const allTokenTypes = lodash_es_compact((0,flatten/* default */.Z)((0,values/* default */.Z)(lexerDefinition.modes)));
4351 const concreteTokenTypes = lodash_es_reject(allTokenTypes, (currType) => currType[PATTERN] === Lexer.NA);
4352 const terminatorCharCodes = getCharCodes(lineTerminatorCharacters);
4353 if (trackLines) {
4354 (0,forEach/* default */.Z)(concreteTokenTypes, (tokType) => {
4355 const currIssue = checkLineBreaksIssues(tokType, terminatorCharCodes);
4356 if (currIssue !== false) {
4357 const message = buildLineBreakIssueMessage(tokType, currIssue);
4358 const warningDescriptor = {
4359 message,
4360 type: currIssue.issue,
4361 tokenType: tokType,
4362 };
4363 warnings.push(warningDescriptor);
4364 }
4365 else {
4366 // we don't want to attempt to scan if the user explicitly specified the line_breaks option.
4367 if ((0,has/* default */.Z)(tokType, "LINE_BREAKS")) {
4368 if (tokType.LINE_BREAKS === true) {
4369 hasAnyLineBreak = true;
4370 }
4371 }
4372 else {
4373 if (canMatchCharCode(terminatorCharCodes, tokType.PATTERN)) {
4374 hasAnyLineBreak = true;
4375 }
4376 }
4377 }
4378 });
4379 }
4380 if (trackLines && !hasAnyLineBreak) {
4381 warnings.push({
4382 message: "Warning: No LINE_BREAKS Found.\n" +
4383 "\tThis Lexer has been defined to track line and column information,\n" +
4384 "\tBut none of the Token Types can be identified as matching a line terminator.\n" +
4385 "\tSee https://chevrotain.io/docs/guide/resolving_lexer_errors.html#LINE_BREAKS \n" +
4386 "\tfor details.",
4387 type: LexerDefinitionErrorType.NO_LINE_BREAKS_FLAGS,
4388 });
4389 }
4390 return warnings;
4391 }
4392 function cloneEmptyGroups(emptyGroups) {
4393 const clonedResult = {};
4394 const groupKeys = (0,keys/* default */.Z)(emptyGroups);
4395 (0,forEach/* default */.Z)(groupKeys, (currKey) => {
4396 const currGroupValue = emptyGroups[currKey];
4397 /* istanbul ignore else */
4398 if ((0,isArray/* default */.Z)(currGroupValue)) {
4399 clonedResult[currKey] = [];
4400 }
4401 else {
4402 throw Error("non exhaustive match");
4403 }
4404 });
4405 return clonedResult;
4406 }
4407 // TODO: refactor to avoid duplication
4408 function isCustomPattern(tokenType) {
4409 const pattern = tokenType.PATTERN;
4410 /* istanbul ignore else */
4411 if (lodash_es_isRegExp(pattern)) {
4412 return false;
4413 }
4414 else if ((0,isFunction/* default */.Z)(pattern)) {
4415 // CustomPatternMatcherFunc - custom patterns do not require any transformations, only wrapping in a RegExp Like object
4416 return true;
4417 }
4418 else if ((0,has/* default */.Z)(pattern, "exec")) {
4419 // ICustomPattern
4420 return true;
4421 }
4422 else if ((0,isString/* default */.Z)(pattern)) {
4423 return false;
4424 }
4425 else {
4426 throw Error("non exhaustive match");
4427 }
4428 }
4429 function isShortPattern(pattern) {
4430 if ((0,isString/* default */.Z)(pattern) && pattern.length === 1) {
4431 return pattern.charCodeAt(0);
4432 }
4433 else {
4434 return false;
4435 }
4436 }
4437 /**
4438 * Faster than using a RegExp for default newline detection during lexing.
4439 */
4440 const LineTerminatorOptimizedTester = {
4441 // implements /\n|\r\n?/g.test
4442 test: function (text) {
4443 const len = text.length;
4444 for (let i = this.lastIndex; i < len; i++) {
4445 const c = text.charCodeAt(i);
4446 if (c === 10) {
4447 this.lastIndex = i + 1;
4448 return true;
4449 }
4450 else if (c === 13) {
4451 if (text.charCodeAt(i + 1) === 10) {
4452 this.lastIndex = i + 2;
4453 }
4454 else {
4455 this.lastIndex = i + 1;
4456 }
4457 return true;
4458 }
4459 }
4460 return false;
4461 },
4462 lastIndex: 0,
4463 };
4464 function checkLineBreaksIssues(tokType, lineTerminatorCharCodes) {
4465 if ((0,has/* default */.Z)(tokType, "LINE_BREAKS")) {
4466 // if the user explicitly declared the line_breaks option we will respect their choice
4467 // and assume it is correct.
4468 return false;
4469 }
4470 else {
4471 /* istanbul ignore else */
4472 if (lodash_es_isRegExp(tokType.PATTERN)) {
4473 try {
4474 // TODO: why is the casting suddenly needed?
4475 canMatchCharCode(lineTerminatorCharCodes, tokType.PATTERN);
4476 }
4477 catch (e) {
4478 /* istanbul ignore next - to test this we would have to mock <canMatchCharCode> to throw an error */
4479 return {
4480 issue: LexerDefinitionErrorType.IDENTIFY_TERMINATOR,
4481 errMsg: e.message,
4482 };
4483 }
4484 return false;
4485 }
4486 else if ((0,isString/* default */.Z)(tokType.PATTERN)) {
4487 // string literal patterns can always be analyzed to detect line terminator usage
4488 return false;
4489 }
4490 else if (isCustomPattern(tokType)) {
4491 // custom token types
4492 return { issue: LexerDefinitionErrorType.CUSTOM_LINE_BREAK };
4493 }
4494 else {
4495 throw Error("non exhaustive match");
4496 }
4497 }
4498 }
4499 function buildLineBreakIssueMessage(tokType, details) {
4500 /* istanbul ignore else */
4501 if (details.issue === LexerDefinitionErrorType.IDENTIFY_TERMINATOR) {
4502 return ("Warning: unable to identify line terminator usage in pattern.\n" +
4503 `\tThe problem is in the <${tokType.name}> Token Type\n` +
4504 `\t Root cause: ${details.errMsg}.\n` +
4505 "\tFor details See: https://chevrotain.io/docs/guide/resolving_lexer_errors.html#IDENTIFY_TERMINATOR");
4506 }
4507 else if (details.issue === LexerDefinitionErrorType.CUSTOM_LINE_BREAK) {
4508 return ("Warning: A Custom Token Pattern should specify the <line_breaks> option.\n" +
4509 `\tThe problem is in the <${tokType.name}> Token Type\n` +
4510 "\tFor details See: https://chevrotain.io/docs/guide/resolving_lexer_errors.html#CUSTOM_LINE_BREAK");
4511 }
4512 else {
4513 throw Error("non exhaustive match");
4514 }
4515 }
4516 function getCharCodes(charsOrCodes) {
4517 const charCodes = (0,map/* default */.Z)(charsOrCodes, (numOrString) => {
4518 if ((0,isString/* default */.Z)(numOrString)) {
4519 return numOrString.charCodeAt(0);
4520 }
4521 else {
4522 return numOrString;
4523 }
4524 });
4525 return charCodes;
4526 }
4527 function addToMapOfArrays(map, key, value) {
4528 if (map[key] === undefined) {
4529 map[key] = [value];
4530 }
4531 else {
4532 map[key].push(value);
4533 }
4534 }
4535 const minOptimizationVal = 256;
4536 /**
4537 * We are mapping charCode above ASCI (256) into buckets each in the size of 256.
4538 * This is because ASCI are the most common start chars so each one of those will get its own
4539 * possible token configs vector.
4540 *
4541 * Tokens starting with charCodes "above" ASCI are uncommon, so we can "afford"
4542 * to place these into buckets of possible token configs, What we gain from
4543 * this is avoiding the case of creating an optimization 'charCodeToPatternIdxToConfig'
4544 * which would contain 10,000+ arrays of small size (e.g unicode Identifiers scenario).
4545 * Our 'charCodeToPatternIdxToConfig' max size will now be:
4546 * 256 + (2^16 / 2^8) - 1 === 511
4547 *
4548 * note the hack for fast division integer part extraction
4549 * See: https://stackoverflow.com/a/4228528
4550 */
4551 let charCodeToOptimizedIdxMap = [];
4552 function charCodeToOptimizedIndex(charCode) {
4553 return charCode < minOptimizationVal
4554 ? charCode
4555 : charCodeToOptimizedIdxMap[charCode];
4556 }
4557 /**
4558 * This is a compromise between cold start / hot running performance
4559 * Creating this array takes ~3ms on a modern machine,
4560 * But if we perform the computation at runtime as needed the CSS Lexer benchmark
4561 * performance degrades by ~10%
4562 *
4563 * TODO: Perhaps it should be lazy initialized only if a charCode > 255 is used.
4564 */
4565 function initCharCodeToOptimizedIndexMap() {
4566 if ((0,isEmpty/* default */.Z)(charCodeToOptimizedIdxMap)) {
4567 charCodeToOptimizedIdxMap = new Array(65536);
4568 for (let i = 0; i < 65536; i++) {
4569 charCodeToOptimizedIdxMap[i] = i > 255 ? 255 + ~~(i / 255) : i;
4570 }
4571 }
4572 }
4573 //# sourceMappingURL=lexer.js.map
4574 // EXTERNAL MODULE: ../node_modules/lodash-es/identity.js
4575 var identity = __webpack_require__(64056);
4576 // EXTERNAL MODULE: ../node_modules/lodash-es/noop.js
4577 var noop = __webpack_require__(10152);
4578 // EXTERNAL MODULE: ../node_modules/lodash-es/last.js
4579 var last = __webpack_require__(36411);
4580 ;// CONCATENATED MODULE: ../node_modules/@chevrotain/utils/lib/src/timer.js
4581 function timer(func) {
4582 const start = new Date().getTime();
4583 const val = func();
4584 const end = new Date().getTime();
4585 const total = end - start;
4586 return { time: total, value: val };
4587 }
4588 //# sourceMappingURL=timer.js.map
4589 ;// CONCATENATED MODULE: ../node_modules/chevrotain/lib/src/scan/tokens.js
4590
4591 function tokenStructuredMatcher(tokInstance, tokConstructor) {
4592 const instanceType = tokInstance.tokenTypeIdx;
4593 if (instanceType === tokConstructor.tokenTypeIdx) {
4594 return true;
4595 }
4596 else {
4597 return (tokConstructor.isParent === true &&
4598 tokConstructor.categoryMatchesMap[instanceType] === true);
4599 }
4600 }
4601 // Optimized tokenMatcher in case our grammar does not use token categories
4602 // Being so tiny it is much more likely to be in-lined and this avoid the function call overhead
4603 function tokenStructuredMatcherNoCategories(token, tokType) {
4604 return token.tokenTypeIdx === tokType.tokenTypeIdx;
4605 }
4606 let tokenShortNameIdx = 1;
4607 const tokenIdxToClass = {};
4608 function augmentTokenTypes(tokenTypes) {
4609 // collect the parent Token Types as well.
4610 const tokenTypesAndParents = expandCategories(tokenTypes);
4611 // add required tokenType and categoryMatches properties
4612 assignTokenDefaultProps(tokenTypesAndParents);
4613 // fill up the categoryMatches
4614 assignCategoriesMapProp(tokenTypesAndParents);
4615 assignCategoriesTokensProp(tokenTypesAndParents);
4616 (0,forEach/* default */.Z)(tokenTypesAndParents, (tokType) => {
4617 tokType.isParent = tokType.categoryMatches.length > 0;
4618 });
4619 }
4620 function expandCategories(tokenTypes) {
4621 let result = (0,lodash_es_clone/* default */.Z)(tokenTypes);
4622 let categories = tokenTypes;
4623 let searching = true;
4624 while (searching) {
4625 categories = lodash_es_compact((0,flatten/* default */.Z)((0,map/* default */.Z)(categories, (currTokType) => currTokType.CATEGORIES)));
4626 const newCategories = lodash_es_difference(categories, result);
4627 result = result.concat(newCategories);
4628 if ((0,isEmpty/* default */.Z)(newCategories)) {
4629 searching = false;
4630 }
4631 else {
4632 categories = newCategories;
4633 }
4634 }
4635 return result;
4636 }
4637 function assignTokenDefaultProps(tokenTypes) {
4638 (0,forEach/* default */.Z)(tokenTypes, (currTokType) => {
4639 if (!hasShortKeyProperty(currTokType)) {
4640 tokenIdxToClass[tokenShortNameIdx] = currTokType;
4641 currTokType.tokenTypeIdx = tokenShortNameIdx++;
4642 }
4643 // CATEGORIES? : TokenType | TokenType[]
4644 if (hasCategoriesProperty(currTokType) &&
4645 !(0,isArray/* default */.Z)(currTokType.CATEGORIES)
4646 // &&
4647 // !isUndefined(currTokType.CATEGORIES.PATTERN)
4648 ) {
4649 currTokType.CATEGORIES = [currTokType.CATEGORIES];
4650 }
4651 if (!hasCategoriesProperty(currTokType)) {
4652 currTokType.CATEGORIES = [];
4653 }
4654 if (!hasExtendingTokensTypesProperty(currTokType)) {
4655 currTokType.categoryMatches = [];
4656 }
4657 if (!hasExtendingTokensTypesMapProperty(currTokType)) {
4658 currTokType.categoryMatchesMap = {};
4659 }
4660 });
4661 }
4662 function assignCategoriesTokensProp(tokenTypes) {
4663 (0,forEach/* default */.Z)(tokenTypes, (currTokType) => {
4664 // avoid duplications
4665 currTokType.categoryMatches = [];
4666 (0,forEach/* default */.Z)(currTokType.categoryMatchesMap, (val, key) => {
4667 currTokType.categoryMatches.push(tokenIdxToClass[key].tokenTypeIdx);
4668 });
4669 });
4670 }
4671 function assignCategoriesMapProp(tokenTypes) {
4672 (0,forEach/* default */.Z)(tokenTypes, (currTokType) => {
4673 singleAssignCategoriesToksMap([], currTokType);
4674 });
4675 }
4676 function singleAssignCategoriesToksMap(path, nextNode) {
4677 (0,forEach/* default */.Z)(path, (pathNode) => {
4678 nextNode.categoryMatchesMap[pathNode.tokenTypeIdx] = true;
4679 });
4680 (0,forEach/* default */.Z)(nextNode.CATEGORIES, (nextCategory) => {
4681 const newPath = path.concat(nextNode);
4682 // avoids infinite loops due to cyclic categories.
4683 if (!lodash_es_includes(newPath, nextCategory)) {
4684 singleAssignCategoriesToksMap(newPath, nextCategory);
4685 }
4686 });
4687 }
4688 function hasShortKeyProperty(tokType) {
4689 return (0,has/* default */.Z)(tokType, "tokenTypeIdx");
4690 }
4691 function hasCategoriesProperty(tokType) {
4692 return (0,has/* default */.Z)(tokType, "CATEGORIES");
4693 }
4694 function hasExtendingTokensTypesProperty(tokType) {
4695 return (0,has/* default */.Z)(tokType, "categoryMatches");
4696 }
4697 function hasExtendingTokensTypesMapProperty(tokType) {
4698 return (0,has/* default */.Z)(tokType, "categoryMatchesMap");
4699 }
4700 function isTokenType(tokType) {
4701 return (0,has/* default */.Z)(tokType, "tokenTypeIdx");
4702 }
4703 //# sourceMappingURL=tokens.js.map
4704 ;// CONCATENATED MODULE: ../node_modules/chevrotain/lib/src/scan/lexer_errors_public.js
4705 const defaultLexerErrorProvider = {
4706 buildUnableToPopLexerModeMessage(token) {
4707 return `Unable to pop Lexer Mode after encountering Token ->${token.image}<- The Mode Stack is empty`;
4708 },
4709 buildUnexpectedCharactersMessage(fullText, startOffset, length, line, column) {
4710 return (`unexpected character: ->${fullText.charAt(startOffset)}<- at offset: ${startOffset},` + ` skipped ${length} characters.`);
4711 },
4712 };
4713 //# sourceMappingURL=lexer_errors_public.js.map
4714 ;// CONCATENATED MODULE: ../node_modules/chevrotain/lib/src/scan/lexer_public.js
4715
4716
4717
4718
4719
4720
4721 var LexerDefinitionErrorType;
4722 (function (LexerDefinitionErrorType) {
4723 LexerDefinitionErrorType[LexerDefinitionErrorType["MISSING_PATTERN"] = 0] = "MISSING_PATTERN";
4724 LexerDefinitionErrorType[LexerDefinitionErrorType["INVALID_PATTERN"] = 1] = "INVALID_PATTERN";
4725 LexerDefinitionErrorType[LexerDefinitionErrorType["EOI_ANCHOR_FOUND"] = 2] = "EOI_ANCHOR_FOUND";
4726 LexerDefinitionErrorType[LexerDefinitionErrorType["UNSUPPORTED_FLAGS_FOUND"] = 3] = "UNSUPPORTED_FLAGS_FOUND";
4727 LexerDefinitionErrorType[LexerDefinitionErrorType["DUPLICATE_PATTERNS_FOUND"] = 4] = "DUPLICATE_PATTERNS_FOUND";
4728 LexerDefinitionErrorType[LexerDefinitionErrorType["INVALID_GROUP_TYPE_FOUND"] = 5] = "INVALID_GROUP_TYPE_FOUND";
4729 LexerDefinitionErrorType[LexerDefinitionErrorType["PUSH_MODE_DOES_NOT_EXIST"] = 6] = "PUSH_MODE_DOES_NOT_EXIST";
4730 LexerDefinitionErrorType[LexerDefinitionErrorType["MULTI_MODE_LEXER_WITHOUT_DEFAULT_MODE"] = 7] = "MULTI_MODE_LEXER_WITHOUT_DEFAULT_MODE";
4731 LexerDefinitionErrorType[LexerDefinitionErrorType["MULTI_MODE_LEXER_WITHOUT_MODES_PROPERTY"] = 8] = "MULTI_MODE_LEXER_WITHOUT_MODES_PROPERTY";
4732 LexerDefinitionErrorType[LexerDefinitionErrorType["MULTI_MODE_LEXER_DEFAULT_MODE_VALUE_DOES_NOT_EXIST"] = 9] = "MULTI_MODE_LEXER_DEFAULT_MODE_VALUE_DOES_NOT_EXIST";
4733 LexerDefinitionErrorType[LexerDefinitionErrorType["LEXER_DEFINITION_CANNOT_CONTAIN_UNDEFINED"] = 10] = "LEXER_DEFINITION_CANNOT_CONTAIN_UNDEFINED";
4734 LexerDefinitionErrorType[LexerDefinitionErrorType["SOI_ANCHOR_FOUND"] = 11] = "SOI_ANCHOR_FOUND";
4735 LexerDefinitionErrorType[LexerDefinitionErrorType["EMPTY_MATCH_PATTERN"] = 12] = "EMPTY_MATCH_PATTERN";
4736 LexerDefinitionErrorType[LexerDefinitionErrorType["NO_LINE_BREAKS_FLAGS"] = 13] = "NO_LINE_BREAKS_FLAGS";
4737 LexerDefinitionErrorType[LexerDefinitionErrorType["UNREACHABLE_PATTERN"] = 14] = "UNREACHABLE_PATTERN";
4738 LexerDefinitionErrorType[LexerDefinitionErrorType["IDENTIFY_TERMINATOR"] = 15] = "IDENTIFY_TERMINATOR";
4739 LexerDefinitionErrorType[LexerDefinitionErrorType["CUSTOM_LINE_BREAK"] = 16] = "CUSTOM_LINE_BREAK";
4740 LexerDefinitionErrorType[LexerDefinitionErrorType["MULTI_MODE_LEXER_LONGER_ALT_NOT_IN_CURRENT_MODE"] = 17] = "MULTI_MODE_LEXER_LONGER_ALT_NOT_IN_CURRENT_MODE";
4741 })(LexerDefinitionErrorType || (LexerDefinitionErrorType = {}));
4742 const DEFAULT_LEXER_CONFIG = {
4743 deferDefinitionErrorsHandling: false,
4744 positionTracking: "full",
4745 lineTerminatorsPattern: /\n|\r\n?/g,
4746 lineTerminatorCharacters: ["\n", "\r"],
4747 ensureOptimizations: false,
4748 safeMode: false,
4749 errorMessageProvider: defaultLexerErrorProvider,
4750 traceInitPerf: false,
4751 skipValidations: false,
4752 recoveryEnabled: true,
4753 };
4754 Object.freeze(DEFAULT_LEXER_CONFIG);
4755 class Lexer {
4756 constructor(lexerDefinition, config = DEFAULT_LEXER_CONFIG) {
4757 this.lexerDefinition = lexerDefinition;
4758 this.lexerDefinitionErrors = [];
4759 this.lexerDefinitionWarning = [];
4760 this.patternIdxToConfig = {};
4761 this.charCodeToPatternIdxToConfig = {};
4762 this.modes = [];
4763 this.emptyGroups = {};
4764 this.trackStartLines = true;
4765 this.trackEndLines = true;
4766 this.hasCustom = false;
4767 this.canModeBeOptimized = {};
4768 // Duplicated from the parser's perf trace trait to allow future extraction
4769 // of the lexer to a separate package.
4770 this.TRACE_INIT = (phaseDesc, phaseImpl) => {
4771 // No need to optimize this using NOOP pattern because
4772 // It is not called in a hot spot...
4773 if (this.traceInitPerf === true) {
4774 this.traceInitIndent++;
4775 const indent = new Array(this.traceInitIndent + 1).join("\t");
4776 if (this.traceInitIndent < this.traceInitMaxIdent) {
4777 console.log(`${indent}--> <${phaseDesc}>`);
4778 }
4779 const { time, value } = timer(phaseImpl);
4780 /* istanbul ignore next - Difficult to reproduce specific performance behavior (>10ms) in tests */
4781 const traceMethod = time > 10 ? console.warn : console.log;
4782 if (this.traceInitIndent < this.traceInitMaxIdent) {
4783 traceMethod(`${indent}<-- <${phaseDesc}> time: ${time}ms`);
4784 }
4785 this.traceInitIndent--;
4786 return value;
4787 }
4788 else {
4789 return phaseImpl();
4790 }
4791 };
4792 if (typeof config === "boolean") {
4793 throw Error("The second argument to the Lexer constructor is now an ILexerConfig Object.\n" +
4794 "a boolean 2nd argument is no longer supported");
4795 }
4796 // todo: defaults func?
4797 this.config = lodash_es_assign({}, DEFAULT_LEXER_CONFIG, config);
4798 const traceInitVal = this.config.traceInitPerf;
4799 if (traceInitVal === true) {
4800 this.traceInitMaxIdent = Infinity;
4801 this.traceInitPerf = true;
4802 }
4803 else if (typeof traceInitVal === "number") {
4804 this.traceInitMaxIdent = traceInitVal;
4805 this.traceInitPerf = true;
4806 }
4807 this.traceInitIndent = -1;
4808 this.TRACE_INIT("Lexer Constructor", () => {
4809 let actualDefinition;
4810 let hasOnlySingleMode = true;
4811 this.TRACE_INIT("Lexer Config handling", () => {
4812 if (this.config.lineTerminatorsPattern ===
4813 DEFAULT_LEXER_CONFIG.lineTerminatorsPattern) {
4814 // optimized built-in implementation for the defaults definition of lineTerminators
4815 this.config.lineTerminatorsPattern = LineTerminatorOptimizedTester;
4816 }
4817 else {
4818 if (this.config.lineTerminatorCharacters ===
4819 DEFAULT_LEXER_CONFIG.lineTerminatorCharacters) {
4820 throw Error("Error: Missing <lineTerminatorCharacters> property on the Lexer config.\n" +
4821 "\tFor details See: https://chevrotain.io/docs/guide/resolving_lexer_errors.html#MISSING_LINE_TERM_CHARS");
4822 }
4823 }
4824 if (config.safeMode && config.ensureOptimizations) {
4825 throw Error('"safeMode" and "ensureOptimizations" flags are mutually exclusive.');
4826 }
4827 this.trackStartLines = /full|onlyStart/i.test(this.config.positionTracking);
4828 this.trackEndLines = /full/i.test(this.config.positionTracking);
4829 // Convert SingleModeLexerDefinition into a IMultiModeLexerDefinition.
4830 if ((0,isArray/* default */.Z)(lexerDefinition)) {
4831 actualDefinition = {
4832 modes: { defaultMode: (0,lodash_es_clone/* default */.Z)(lexerDefinition) },
4833 defaultMode: DEFAULT_MODE,
4834 };
4835 }
4836 else {
4837 // no conversion needed, input should already be a IMultiModeLexerDefinition
4838 hasOnlySingleMode = false;
4839 actualDefinition = (0,lodash_es_clone/* default */.Z)(lexerDefinition);
4840 }
4841 });
4842 if (this.config.skipValidations === false) {
4843 this.TRACE_INIT("performRuntimeChecks", () => {
4844 this.lexerDefinitionErrors = this.lexerDefinitionErrors.concat(performRuntimeChecks(actualDefinition, this.trackStartLines, this.config.lineTerminatorCharacters));
4845 });
4846 this.TRACE_INIT("performWarningRuntimeChecks", () => {
4847 this.lexerDefinitionWarning = this.lexerDefinitionWarning.concat(performWarningRuntimeChecks(actualDefinition, this.trackStartLines, this.config.lineTerminatorCharacters));
4848 });
4849 }
4850 // for extra robustness to avoid throwing an none informative error message
4851 actualDefinition.modes = actualDefinition.modes
4852 ? actualDefinition.modes
4853 : {};
4854 // an error of undefined TokenTypes will be detected in "performRuntimeChecks" above.
4855 // this transformation is to increase robustness in the case of partially invalid lexer definition.
4856 (0,forEach/* default */.Z)(actualDefinition.modes, (currModeValue, currModeName) => {
4857 actualDefinition.modes[currModeName] = lodash_es_reject(currModeValue, (currTokType) => (0,isUndefined/* default */.Z)(currTokType));
4858 });
4859 const allModeNames = (0,keys/* default */.Z)(actualDefinition.modes);
4860 (0,forEach/* default */.Z)(actualDefinition.modes, (currModDef, currModName) => {
4861 this.TRACE_INIT(`Mode: <${currModName}> processing`, () => {
4862 this.modes.push(currModName);
4863 if (this.config.skipValidations === false) {
4864 this.TRACE_INIT(`validatePatterns`, () => {
4865 this.lexerDefinitionErrors = this.lexerDefinitionErrors.concat(validatePatterns(currModDef, allModeNames));
4866 });
4867 }
4868 // If definition errors were encountered, the analysis phase may fail unexpectedly/
4869 // Considering a lexer with definition errors may never be used, there is no point
4870 // to performing the analysis anyhow...
4871 if ((0,isEmpty/* default */.Z)(this.lexerDefinitionErrors)) {
4872 augmentTokenTypes(currModDef);
4873 let currAnalyzeResult;
4874 this.TRACE_INIT(`analyzeTokenTypes`, () => {
4875 currAnalyzeResult = analyzeTokenTypes(currModDef, {
4876 lineTerminatorCharacters: this.config.lineTerminatorCharacters,
4877 positionTracking: config.positionTracking,
4878 ensureOptimizations: config.ensureOptimizations,
4879 safeMode: config.safeMode,
4880 tracer: this.TRACE_INIT,
4881 });
4882 });
4883 this.patternIdxToConfig[currModName] =
4884 currAnalyzeResult.patternIdxToConfig;
4885 this.charCodeToPatternIdxToConfig[currModName] =
4886 currAnalyzeResult.charCodeToPatternIdxToConfig;
4887 this.emptyGroups = lodash_es_assign({}, this.emptyGroups, currAnalyzeResult.emptyGroups);
4888 this.hasCustom = currAnalyzeResult.hasCustom || this.hasCustom;
4889 this.canModeBeOptimized[currModName] =
4890 currAnalyzeResult.canBeOptimized;
4891 }
4892 });
4893 });
4894 this.defaultMode = actualDefinition.defaultMode;
4895 if (!(0,isEmpty/* default */.Z)(this.lexerDefinitionErrors) &&
4896 !this.config.deferDefinitionErrorsHandling) {
4897 const allErrMessages = (0,map/* default */.Z)(this.lexerDefinitionErrors, (error) => {
4898 return error.message;
4899 });
4900 const allErrMessagesString = allErrMessages.join("-----------------------\n");
4901 throw new Error("Errors detected in definition of Lexer:\n" + allErrMessagesString);
4902 }
4903 // Only print warning if there are no errors, This will avoid pl
4904 (0,forEach/* default */.Z)(this.lexerDefinitionWarning, (warningDescriptor) => {
4905 PRINT_WARNING(warningDescriptor.message);
4906 });
4907 this.TRACE_INIT("Choosing sub-methods implementations", () => {
4908 // Choose the relevant internal implementations for this specific parser.
4909 // These implementations should be in-lined by the JavaScript engine
4910 // to provide optimal performance in each scenario.
4911 if (SUPPORT_STICKY) {
4912 this.chopInput = identity/* default */.Z;
4913 this.match = this.matchWithTest;
4914 }
4915 else {
4916 this.updateLastIndex = noop/* default */.Z;
4917 this.match = this.matchWithExec;
4918 }
4919 if (hasOnlySingleMode) {
4920 this.handleModes = noop/* default */.Z;
4921 }
4922 if (this.trackStartLines === false) {
4923 this.computeNewColumn = identity/* default */.Z;
4924 }
4925 if (this.trackEndLines === false) {
4926 this.updateTokenEndLineColumnLocation = noop/* default */.Z;
4927 }
4928 if (/full/i.test(this.config.positionTracking)) {
4929 this.createTokenInstance = this.createFullToken;
4930 }
4931 else if (/onlyStart/i.test(this.config.positionTracking)) {
4932 this.createTokenInstance = this.createStartOnlyToken;
4933 }
4934 else if (/onlyOffset/i.test(this.config.positionTracking)) {
4935 this.createTokenInstance = this.createOffsetOnlyToken;
4936 }
4937 else {
4938 throw Error(`Invalid <positionTracking> config option: "${this.config.positionTracking}"`);
4939 }
4940 if (this.hasCustom) {
4941 this.addToken = this.addTokenUsingPush;
4942 this.handlePayload = this.handlePayloadWithCustom;
4943 }
4944 else {
4945 this.addToken = this.addTokenUsingMemberAccess;
4946 this.handlePayload = this.handlePayloadNoCustom;
4947 }
4948 });
4949 this.TRACE_INIT("Failed Optimization Warnings", () => {
4950 const unOptimizedModes = (0,reduce/* default */.Z)(this.canModeBeOptimized, (cannotBeOptimized, canBeOptimized, modeName) => {
4951 if (canBeOptimized === false) {
4952 cannotBeOptimized.push(modeName);
4953 }
4954 return cannotBeOptimized;
4955 }, []);
4956 if (config.ensureOptimizations && !(0,isEmpty/* default */.Z)(unOptimizedModes)) {
4957 throw Error(`Lexer Modes: < ${unOptimizedModes.join(", ")} > cannot be optimized.\n` +
4958 '\t Disable the "ensureOptimizations" lexer config flag to silently ignore this and run the lexer in an un-optimized mode.\n' +
4959 "\t Or inspect the console log for details on how to resolve these issues.");
4960 }
4961 });
4962 this.TRACE_INIT("clearRegExpParserCache", () => {
4963 clearRegExpParserCache();
4964 });
4965 this.TRACE_INIT("toFastProperties", () => {
4966 toFastProperties(this);
4967 });
4968 });
4969 }
4970 tokenize(text, initialMode = this.defaultMode) {
4971 if (!(0,isEmpty/* default */.Z)(this.lexerDefinitionErrors)) {
4972 const allErrMessages = (0,map/* default */.Z)(this.lexerDefinitionErrors, (error) => {
4973 return error.message;
4974 });
4975 const allErrMessagesString = allErrMessages.join("-----------------------\n");
4976 throw new Error("Unable to Tokenize because Errors detected in definition of Lexer:\n" +
4977 allErrMessagesString);
4978 }
4979 return this.tokenizeInternal(text, initialMode);
4980 }
4981 // There is quite a bit of duplication between this and "tokenizeInternalLazy"
4982 // This is intentional due to performance considerations.
4983 // this method also used quite a bit of `!` none null assertions because it is too optimized
4984 // for `tsc` to always understand it is "safe"
4985 tokenizeInternal(text, initialMode) {
4986 let i, j, k, matchAltImage, longerAlt, matchedImage, payload, altPayload, imageLength, group, tokType, newToken, errLength, droppedChar, msg, match;
4987 const orgText = text;
4988 const orgLength = orgText.length;
4989 let offset = 0;
4990 let matchedTokensIndex = 0;
4991 // initializing the tokensArray to the "guessed" size.
4992 // guessing too little will still reduce the number of array re-sizes on pushes.
4993 // guessing too large (Tested by guessing x4 too large) may cost a bit more of memory
4994 // but would still have a faster runtime by avoiding (All but one) array resizing.
4995 const guessedNumberOfTokens = this.hasCustom
4996 ? 0 // will break custom token pattern APIs the matchedTokens array will contain undefined elements.
4997 : Math.floor(text.length / 10);
4998 const matchedTokens = new Array(guessedNumberOfTokens);
4999 const errors = [];
5000 let line = this.trackStartLines ? 1 : undefined;
5001 let column = this.trackStartLines ? 1 : undefined;
5002 const groups = cloneEmptyGroups(this.emptyGroups);
5003 const trackLines = this.trackStartLines;
5004 const lineTerminatorPattern = this.config.lineTerminatorsPattern;
5005 let currModePatternsLength = 0;
5006 let patternIdxToConfig = [];
5007 let currCharCodeToPatternIdxToConfig = [];
5008 const modeStack = [];
5009 const emptyArray = [];
5010 Object.freeze(emptyArray);
5011 let getPossiblePatterns;
5012 function getPossiblePatternsSlow() {
5013 return patternIdxToConfig;
5014 }
5015 function getPossiblePatternsOptimized(charCode) {
5016 const optimizedCharIdx = charCodeToOptimizedIndex(charCode);
5017 const possiblePatterns = currCharCodeToPatternIdxToConfig[optimizedCharIdx];
5018 if (possiblePatterns === undefined) {
5019 return emptyArray;
5020 }
5021 else {
5022 return possiblePatterns;
5023 }
5024 }
5025 const pop_mode = (popToken) => {
5026 // TODO: perhaps avoid this error in the edge case there is no more input?
5027 if (modeStack.length === 1 &&
5028 // if we have both a POP_MODE and a PUSH_MODE this is in-fact a "transition"
5029 // So no error should occur.
5030 popToken.tokenType.PUSH_MODE === undefined) {
5031 // if we try to pop the last mode there lexer will no longer have ANY mode.
5032 // thus the pop is ignored, an error will be created and the lexer will continue parsing in the previous mode.
5033 const msg = this.config.errorMessageProvider.buildUnableToPopLexerModeMessage(popToken);
5034 errors.push({
5035 offset: popToken.startOffset,
5036 line: popToken.startLine,
5037 column: popToken.startColumn,
5038 length: popToken.image.length,
5039 message: msg,
5040 });
5041 }
5042 else {
5043 modeStack.pop();
5044 const newMode = (0,last/* default */.Z)(modeStack);
5045 patternIdxToConfig = this.patternIdxToConfig[newMode];
5046 currCharCodeToPatternIdxToConfig =
5047 this.charCodeToPatternIdxToConfig[newMode];
5048 currModePatternsLength = patternIdxToConfig.length;
5049 const modeCanBeOptimized = this.canModeBeOptimized[newMode] && this.config.safeMode === false;
5050 if (currCharCodeToPatternIdxToConfig && modeCanBeOptimized) {
5051 getPossiblePatterns = getPossiblePatternsOptimized;
5052 }
5053 else {
5054 getPossiblePatterns = getPossiblePatternsSlow;
5055 }
5056 }
5057 };
5058 function push_mode(newMode) {
5059 modeStack.push(newMode);
5060 currCharCodeToPatternIdxToConfig =
5061 this.charCodeToPatternIdxToConfig[newMode];
5062 patternIdxToConfig = this.patternIdxToConfig[newMode];
5063 currModePatternsLength = patternIdxToConfig.length;
5064 currModePatternsLength = patternIdxToConfig.length;
5065 const modeCanBeOptimized = this.canModeBeOptimized[newMode] && this.config.safeMode === false;
5066 if (currCharCodeToPatternIdxToConfig && modeCanBeOptimized) {
5067 getPossiblePatterns = getPossiblePatternsOptimized;
5068 }
5069 else {
5070 getPossiblePatterns = getPossiblePatternsSlow;
5071 }
5072 }
5073 // this pattern seems to avoid a V8 de-optimization, although that de-optimization does not
5074 // seem to matter performance wise.
5075 push_mode.call(this, initialMode);
5076 let currConfig;
5077 const recoveryEnabled = this.config.recoveryEnabled;
5078 while (offset < orgLength) {
5079 matchedImage = null;
5080 const nextCharCode = orgText.charCodeAt(offset);
5081 const chosenPatternIdxToConfig = getPossiblePatterns(nextCharCode);
5082 const chosenPatternsLength = chosenPatternIdxToConfig.length;
5083 for (i = 0; i < chosenPatternsLength; i++) {
5084 currConfig = chosenPatternIdxToConfig[i];
5085 const currPattern = currConfig.pattern;
5086 payload = null;
5087 // manually in-lined because > 600 chars won't be in-lined in V8
5088 const singleCharCode = currConfig.short;
5089 if (singleCharCode !== false) {
5090 if (nextCharCode === singleCharCode) {
5091 // single character string
5092 matchedImage = currPattern;
5093 }
5094 }
5095 else if (currConfig.isCustom === true) {
5096 match = currPattern.exec(orgText, offset, matchedTokens, groups);
5097 if (match !== null) {
5098 matchedImage = match[0];
5099 if (match.payload !== undefined) {
5100 payload = match.payload;
5101 }
5102 }
5103 else {
5104 matchedImage = null;
5105 }
5106 }
5107 else {
5108 this.updateLastIndex(currPattern, offset);
5109 matchedImage = this.match(currPattern, text, offset);
5110 }
5111 if (matchedImage !== null) {
5112 // even though this pattern matched we must try a another longer alternative.
5113 // this can be used to prioritize keywords over identifiers
5114 longerAlt = currConfig.longerAlt;
5115 if (longerAlt !== undefined) {
5116 // TODO: micro optimize, avoid extra prop access
5117 // by saving/linking longerAlt on the original config?
5118 const longerAltLength = longerAlt.length;
5119 for (k = 0; k < longerAltLength; k++) {
5120 const longerAltConfig = patternIdxToConfig[longerAlt[k]];
5121 const longerAltPattern = longerAltConfig.pattern;
5122 altPayload = null;
5123 // single Char can never be a longer alt so no need to test it.
5124 // manually in-lined because > 600 chars won't be in-lined in V8
5125 if (longerAltConfig.isCustom === true) {
5126 match = longerAltPattern.exec(orgText, offset, matchedTokens, groups);
5127 if (match !== null) {
5128 matchAltImage = match[0];
5129 if (match.payload !== undefined) {
5130 altPayload = match.payload;
5131 }
5132 }
5133 else {
5134 matchAltImage = null;
5135 }
5136 }
5137 else {
5138 this.updateLastIndex(longerAltPattern, offset);
5139 matchAltImage = this.match(longerAltPattern, text, offset);
5140 }
5141 if (matchAltImage && matchAltImage.length > matchedImage.length) {
5142 matchedImage = matchAltImage;
5143 payload = altPayload;
5144 currConfig = longerAltConfig;
5145 // Exit the loop early after matching one of the longer alternatives
5146 // The first matched alternative takes precedence
5147 break;
5148 }
5149 }
5150 }
5151 break;
5152 }
5153 }
5154 // successful match
5155 if (matchedImage !== null) {
5156 imageLength = matchedImage.length;
5157 group = currConfig.group;
5158 if (group !== undefined) {
5159 tokType = currConfig.tokenTypeIdx;
5160 // TODO: "offset + imageLength" and the new column may be computed twice in case of "full" location information inside
5161 // createFullToken method
5162 newToken = this.createTokenInstance(matchedImage, offset, tokType, currConfig.tokenType, line, column, imageLength);
5163 this.handlePayload(newToken, payload);
5164 // TODO: optimize NOOP in case there are no special groups?
5165 if (group === false) {
5166 matchedTokensIndex = this.addToken(matchedTokens, matchedTokensIndex, newToken);
5167 }
5168 else {
5169 groups[group].push(newToken);
5170 }
5171 }
5172 text = this.chopInput(text, imageLength);
5173 offset = offset + imageLength;
5174 // TODO: with newlines the column may be assigned twice
5175 column = this.computeNewColumn(column, imageLength);
5176 if (trackLines === true && currConfig.canLineTerminator === true) {
5177 let numOfLTsInMatch = 0;
5178 let foundTerminator;
5179 let lastLTEndOffset;
5180 lineTerminatorPattern.lastIndex = 0;
5181 do {
5182 foundTerminator = lineTerminatorPattern.test(matchedImage);
5183 if (foundTerminator === true) {
5184 lastLTEndOffset = lineTerminatorPattern.lastIndex - 1;
5185 numOfLTsInMatch++;
5186 }
5187 } while (foundTerminator === true);
5188 if (numOfLTsInMatch !== 0) {
5189 line = line + numOfLTsInMatch;
5190 column = imageLength - lastLTEndOffset;
5191 this.updateTokenEndLineColumnLocation(newToken, group, lastLTEndOffset, numOfLTsInMatch, line, column, imageLength);
5192 }
5193 }
5194 // will be NOOP if no modes present
5195 this.handleModes(currConfig, pop_mode, push_mode, newToken);
5196 }
5197 else {
5198 // error recovery, drop characters until we identify a valid token's start point
5199 const errorStartOffset = offset;
5200 const errorLine = line;
5201 const errorColumn = column;
5202 let foundResyncPoint = recoveryEnabled === false;
5203 while (foundResyncPoint === false && offset < orgLength) {
5204 // Identity Func (when sticky flag is enabled)
5205 text = this.chopInput(text, 1);
5206 offset++;
5207 for (j = 0; j < currModePatternsLength; j++) {
5208 const currConfig = patternIdxToConfig[j];
5209 const currPattern = currConfig.pattern;
5210 // manually in-lined because > 600 chars won't be in-lined in V8
5211 const singleCharCode = currConfig.short;
5212 if (singleCharCode !== false) {
5213 if (orgText.charCodeAt(offset) === singleCharCode) {
5214 // single character string
5215 foundResyncPoint = true;
5216 }
5217 }
5218 else if (currConfig.isCustom === true) {
5219 foundResyncPoint =
5220 currPattern.exec(orgText, offset, matchedTokens, groups) !== null;
5221 }
5222 else {
5223 this.updateLastIndex(currPattern, offset);
5224 foundResyncPoint = currPattern.exec(text) !== null;
5225 }
5226 if (foundResyncPoint === true) {
5227 break;
5228 }
5229 }
5230 }
5231 errLength = offset - errorStartOffset;
5232 column = this.computeNewColumn(column, errLength);
5233 // at this point we either re-synced or reached the end of the input text
5234 msg = this.config.errorMessageProvider.buildUnexpectedCharactersMessage(orgText, errorStartOffset, errLength, errorLine, errorColumn);
5235 errors.push({
5236 offset: errorStartOffset,
5237 line: errorLine,
5238 column: errorColumn,
5239 length: errLength,
5240 message: msg,
5241 });
5242 if (recoveryEnabled === false) {
5243 break;
5244 }
5245 }
5246 }
5247 // if we do have custom patterns which push directly into the
5248 // TODO: custom tokens should not push directly??
5249 if (!this.hasCustom) {
5250 // if we guessed a too large size for the tokens array this will shrink it to the right size.
5251 matchedTokens.length = matchedTokensIndex;
5252 }
5253 return {
5254 tokens: matchedTokens,
5255 groups: groups,
5256 errors: errors,
5257 };
5258 }
5259 handleModes(config, pop_mode, push_mode, newToken) {
5260 if (config.pop === true) {
5261 // need to save the PUSH_MODE property as if the mode is popped
5262 // patternIdxToPopMode is updated to reflect the new mode after popping the stack
5263 const pushMode = config.push;
5264 pop_mode(newToken);
5265 if (pushMode !== undefined) {
5266 push_mode.call(this, pushMode);
5267 }
5268 }
5269 else if (config.push !== undefined) {
5270 push_mode.call(this, config.push);
5271 }
5272 }
5273 chopInput(text, length) {
5274 return text.substring(length);
5275 }
5276 updateLastIndex(regExp, newLastIndex) {
5277 regExp.lastIndex = newLastIndex;
5278 }
5279 // TODO: decrease this under 600 characters? inspect stripping comments option in TSC compiler
5280 updateTokenEndLineColumnLocation(newToken, group, lastLTIdx, numOfLTsInMatch, line, column, imageLength) {
5281 let lastCharIsLT, fixForEndingInLT;
5282 if (group !== undefined) {
5283 // a none skipped multi line Token, need to update endLine/endColumn
5284 lastCharIsLT = lastLTIdx === imageLength - 1;
5285 fixForEndingInLT = lastCharIsLT ? -1 : 0;
5286 if (!(numOfLTsInMatch === 1 && lastCharIsLT === true)) {
5287 // if a token ends in a LT that last LT only affects the line numbering of following Tokens
5288 newToken.endLine = line + fixForEndingInLT;
5289 // the last LT in a token does not affect the endColumn either as the [columnStart ... columnEnd)
5290 // inclusive to exclusive range.
5291 newToken.endColumn = column - 1 + -fixForEndingInLT;
5292 }
5293 // else single LT in the last character of a token, no need to modify the endLine/EndColumn
5294 }
5295 }
5296 computeNewColumn(oldColumn, imageLength) {
5297 return oldColumn + imageLength;
5298 }
5299 createOffsetOnlyToken(image, startOffset, tokenTypeIdx, tokenType) {
5300 return {
5301 image,
5302 startOffset,
5303 tokenTypeIdx,
5304 tokenType,
5305 };
5306 }
5307 createStartOnlyToken(image, startOffset, tokenTypeIdx, tokenType, startLine, startColumn) {
5308 return {
5309 image,
5310 startOffset,
5311 startLine,
5312 startColumn,
5313 tokenTypeIdx,
5314 tokenType,
5315 };
5316 }
5317 createFullToken(image, startOffset, tokenTypeIdx, tokenType, startLine, startColumn, imageLength) {
5318 return {
5319 image,
5320 startOffset,
5321 endOffset: startOffset + imageLength - 1,
5322 startLine,
5323 endLine: startLine,
5324 startColumn,
5325 endColumn: startColumn + imageLength - 1,
5326 tokenTypeIdx,
5327 tokenType,
5328 };
5329 }
5330 addTokenUsingPush(tokenVector, index, tokenToAdd) {
5331 tokenVector.push(tokenToAdd);
5332 return index;
5333 }
5334 addTokenUsingMemberAccess(tokenVector, index, tokenToAdd) {
5335 tokenVector[index] = tokenToAdd;
5336 index++;
5337 return index;
5338 }
5339 handlePayloadNoCustom(token, payload) { }
5340 handlePayloadWithCustom(token, payload) {
5341 if (payload !== null) {
5342 token.payload = payload;
5343 }
5344 }
5345 matchWithTest(pattern, text, offset) {
5346 const found = pattern.test(text);
5347 if (found === true) {
5348 return text.substring(offset, pattern.lastIndex);
5349 }
5350 return null;
5351 }
5352 matchWithExec(pattern, text) {
5353 const regExpArray = pattern.exec(text);
5354 return regExpArray !== null ? regExpArray[0] : null;
5355 }
5356 }
5357 Lexer.SKIPPED = "This marks a skipped Token pattern, this means each token identified by it will" +
5358 "be consumed and then thrown into oblivion, this can be used to for example to completely ignore whitespace.";
5359 Lexer.NA = /NOT_APPLICABLE/;
5360 //# sourceMappingURL=lexer_public.js.map
5361 ;// CONCATENATED MODULE: ../node_modules/chevrotain/lib/src/scan/tokens_public.js
5362
5363
5364
5365 function tokens_public_tokenLabel(tokType) {
5366 if (tokens_public_hasTokenLabel(tokType)) {
5367 return tokType.LABEL;
5368 }
5369 else {
5370 return tokType.name;
5371 }
5372 }
5373 function tokenName(tokType) {
5374 return tokType.name;
5375 }
5376 function tokens_public_hasTokenLabel(obj) {
5377 return (0,isString/* default */.Z)(obj.LABEL) && obj.LABEL !== "";
5378 }
5379 const PARENT = "parent";
5380 const CATEGORIES = "categories";
5381 const LABEL = "label";
5382 const GROUP = "group";
5383 const PUSH_MODE = "push_mode";
5384 const POP_MODE = "pop_mode";
5385 const LONGER_ALT = "longer_alt";
5386 const LINE_BREAKS = "line_breaks";
5387 const START_CHARS_HINT = "start_chars_hint";
5388 function createToken(config) {
5389 return createTokenInternal(config);
5390 }
5391 function createTokenInternal(config) {
5392 const pattern = config.pattern;
5393 const tokenType = {};
5394 tokenType.name = config.name;
5395 if (!(0,isUndefined/* default */.Z)(pattern)) {
5396 tokenType.PATTERN = pattern;
5397 }
5398 if ((0,has/* default */.Z)(config, PARENT)) {
5399 throw ("The parent property is no longer supported.\n" +
5400 "See: https://github.com/chevrotain/chevrotain/issues/564#issuecomment-349062346 for details.");
5401 }
5402 if ((0,has/* default */.Z)(config, CATEGORIES)) {
5403 // casting to ANY as this will be fixed inside `augmentTokenTypes``
5404 tokenType.CATEGORIES = config[CATEGORIES];
5405 }
5406 augmentTokenTypes([tokenType]);
5407 if ((0,has/* default */.Z)(config, LABEL)) {
5408 tokenType.LABEL = config[LABEL];
5409 }
5410 if ((0,has/* default */.Z)(config, GROUP)) {
5411 tokenType.GROUP = config[GROUP];
5412 }
5413 if ((0,has/* default */.Z)(config, POP_MODE)) {
5414 tokenType.POP_MODE = config[POP_MODE];
5415 }
5416 if ((0,has/* default */.Z)(config, PUSH_MODE)) {
5417 tokenType.PUSH_MODE = config[PUSH_MODE];
5418 }
5419 if ((0,has/* default */.Z)(config, LONGER_ALT)) {
5420 tokenType.LONGER_ALT = config[LONGER_ALT];
5421 }
5422 if ((0,has/* default */.Z)(config, LINE_BREAKS)) {
5423 tokenType.LINE_BREAKS = config[LINE_BREAKS];
5424 }
5425 if ((0,has/* default */.Z)(config, START_CHARS_HINT)) {
5426 tokenType.START_CHARS_HINT = config[START_CHARS_HINT];
5427 }
5428 return tokenType;
5429 }
5430 const EOF = createToken({ name: "EOF", pattern: Lexer.NA });
5431 augmentTokenTypes([EOF]);
5432 function createTokenInstance(tokType, image, startOffset, endOffset, startLine, endLine, startColumn, endColumn) {
5433 return {
5434 image,
5435 startOffset,
5436 endOffset,
5437 startLine,
5438 endLine,
5439 startColumn,
5440 endColumn,
5441 tokenTypeIdx: tokType.tokenTypeIdx,
5442 tokenType: tokType,
5443 };
5444 }
5445 function tokenMatcher(token, tokType) {
5446 return tokenStructuredMatcher(token, tokType);
5447 }
5448 //# sourceMappingURL=tokens_public.js.map
5449 ;// CONCATENATED MODULE: ../node_modules/chevrotain/lib/src/parse/errors_public.js
5450
5451
5452
5453 const defaultParserErrorProvider = {
5454 buildMismatchTokenMessage({ expected, actual, previous, ruleName }) {
5455 const hasLabel = tokens_public_hasTokenLabel(expected);
5456 const expectedMsg = hasLabel
5457 ? `--> ${tokens_public_tokenLabel(expected)} <--`
5458 : `token of type --> ${expected.name} <--`;
5459 const msg = `Expecting ${expectedMsg} but found --> '${actual.image}' <--`;
5460 return msg;
5461 },
5462 buildNotAllInputParsedMessage({ firstRedundant, ruleName }) {
5463 return "Redundant input, expecting EOF but found: " + firstRedundant.image;
5464 },
5465 buildNoViableAltMessage({ expectedPathsPerAlt, actual, previous, customUserDescription, ruleName, }) {
5466 const errPrefix = "Expecting: ";
5467 // TODO: issue: No Viable Alternative Error may have incomplete details. #502
5468 const actualText = lodash_es_head(actual).image;
5469 const errSuffix = "\nbut found: '" + actualText + "'";
5470 if (customUserDescription) {
5471 return errPrefix + customUserDescription + errSuffix;
5472 }
5473 else {
5474 const allLookAheadPaths = (0,reduce/* default */.Z)(expectedPathsPerAlt, (result, currAltPaths) => result.concat(currAltPaths), []);
5475 const nextValidTokenSequences = (0,map/* default */.Z)(allLookAheadPaths, (currPath) => `[${(0,map/* default */.Z)(currPath, (currTokenType) => tokens_public_tokenLabel(currTokenType)).join(", ")}]`);
5476 const nextValidSequenceItems = (0,map/* default */.Z)(nextValidTokenSequences, (itemMsg, idx) => ` ${idx + 1}. ${itemMsg}`);
5477 const calculatedDescription = `one of these possible Token sequences:\n${nextValidSequenceItems.join("\n")}`;
5478 return errPrefix + calculatedDescription + errSuffix;
5479 }
5480 },
5481 buildEarlyExitMessage({ expectedIterationPaths, actual, customUserDescription, ruleName, }) {
5482 const errPrefix = "Expecting: ";
5483 // TODO: issue: No Viable Alternative Error may have incomplete details. #502
5484 const actualText = lodash_es_head(actual).image;
5485 const errSuffix = "\nbut found: '" + actualText + "'";
5486 if (customUserDescription) {
5487 return errPrefix + customUserDescription + errSuffix;
5488 }
5489 else {
5490 const nextValidTokenSequences = (0,map/* default */.Z)(expectedIterationPaths, (currPath) => `[${(0,map/* default */.Z)(currPath, (currTokenType) => tokens_public_tokenLabel(currTokenType)).join(",")}]`);
5491 const calculatedDescription = `expecting at least one iteration which starts with one of these possible Token sequences::\n ` +
5492 `<${nextValidTokenSequences.join(" ,")}>`;
5493 return errPrefix + calculatedDescription + errSuffix;
5494 }
5495 },
5496 };
5497 Object.freeze(defaultParserErrorProvider);
5498 const defaultGrammarResolverErrorProvider = {
5499 buildRuleNotFoundError(topLevelRule, undefinedRule) {
5500 const msg = "Invalid grammar, reference to a rule which is not defined: ->" +
5501 undefinedRule.nonTerminalName +
5502 "<-\n" +
5503 "inside top level rule: ->" +
5504 topLevelRule.name +
5505 "<-";
5506 return msg;
5507 },
5508 };
5509 const defaultGrammarValidatorErrorProvider = {
5510 buildDuplicateFoundError(topLevelRule, duplicateProds) {
5511 function getExtraProductionArgument(prod) {
5512 if (prod instanceof Terminal) {
5513 return prod.terminalType.name;
5514 }
5515 else if (prod instanceof NonTerminal) {
5516 return prod.nonTerminalName;
5517 }
5518 else {
5519 return "";
5520 }
5521 }
5522 const topLevelName = topLevelRule.name;
5523 const duplicateProd = lodash_es_head(duplicateProds);
5524 const index = duplicateProd.idx;
5525 const dslName = getProductionDslName(duplicateProd);
5526 const extraArgument = getExtraProductionArgument(duplicateProd);
5527 const hasExplicitIndex = index > 0;
5528 let msg = `->${dslName}${hasExplicitIndex ? index : ""}<- ${extraArgument ? `with argument: ->${extraArgument}<-` : ""}
5529 appears more than once (${duplicateProds.length} times) in the top level rule: ->${topLevelName}<-.
5530 For further details see: https://chevrotain.io/docs/FAQ.html#NUMERICAL_SUFFIXES
5531 `;
5532 // white space trimming time! better to trim afterwards as it allows to use WELL formatted multi line template strings...
5533 msg = msg.replace(/[ \t]+/g, " ");
5534 msg = msg.replace(/\s\s+/g, "\n");
5535 return msg;
5536 },
5537 buildNamespaceConflictError(rule) {
5538 const errMsg = `Namespace conflict found in grammar.\n` +
5539 `The grammar has both a Terminal(Token) and a Non-Terminal(Rule) named: <${rule.name}>.\n` +
5540 `To resolve this make sure each Terminal and Non-Terminal names are unique\n` +
5541 `This is easy to accomplish by using the convention that Terminal names start with an uppercase letter\n` +
5542 `and Non-Terminal names start with a lower case letter.`;
5543 return errMsg;
5544 },
5545 buildAlternationPrefixAmbiguityError(options) {
5546 const pathMsg = (0,map/* default */.Z)(options.prefixPath, (currTok) => tokens_public_tokenLabel(currTok)).join(", ");
5547 const occurrence = options.alternation.idx === 0 ? "" : options.alternation.idx;
5548 const errMsg = `Ambiguous alternatives: <${options.ambiguityIndices.join(" ,")}> due to common lookahead prefix\n` +
5549 `in <OR${occurrence}> inside <${options.topLevelRule.name}> Rule,\n` +
5550 `<${pathMsg}> may appears as a prefix path in all these alternatives.\n` +
5551 `See: https://chevrotain.io/docs/guide/resolving_grammar_errors.html#COMMON_PREFIX\n` +
5552 `For Further details.`;
5553 return errMsg;
5554 },
5555 buildAlternationAmbiguityError(options) {
5556 const pathMsg = (0,map/* default */.Z)(options.prefixPath, (currtok) => tokens_public_tokenLabel(currtok)).join(", ");
5557 const occurrence = options.alternation.idx === 0 ? "" : options.alternation.idx;
5558 let currMessage = `Ambiguous Alternatives Detected: <${options.ambiguityIndices.join(" ,")}> in <OR${occurrence}>` +
5559 ` inside <${options.topLevelRule.name}> Rule,\n` +
5560 `<${pathMsg}> may appears as a prefix path in all these alternatives.\n`;
5561 currMessage =
5562 currMessage +
5563 `See: https://chevrotain.io/docs/guide/resolving_grammar_errors.html#AMBIGUOUS_ALTERNATIVES\n` +
5564 `For Further details.`;
5565 return currMessage;
5566 },
5567 buildEmptyRepetitionError(options) {
5568 let dslName = getProductionDslName(options.repetition);
5569 if (options.repetition.idx !== 0) {
5570 dslName += options.repetition.idx;
5571 }
5572 const errMsg = `The repetition <${dslName}> within Rule <${options.topLevelRule.name}> can never consume any tokens.\n` +
5573 `This could lead to an infinite loop.`;
5574 return errMsg;
5575 },
5576 // TODO: remove - `errors_public` from nyc.config.js exclude
5577 // once this method is fully removed from this file
5578 buildTokenNameError(options) {
5579 /* istanbul ignore next */
5580 return "deprecated";
5581 },
5582 buildEmptyAlternationError(options) {
5583 const errMsg = `Ambiguous empty alternative: <${options.emptyChoiceIdx + 1}>` +
5584 ` in <OR${options.alternation.idx}> inside <${options.topLevelRule.name}> Rule.\n` +
5585 `Only the last alternative may be an empty alternative.`;
5586 return errMsg;
5587 },
5588 buildTooManyAlternativesError(options) {
5589 const errMsg = `An Alternation cannot have more than 256 alternatives:\n` +
5590 `<OR${options.alternation.idx}> inside <${options.topLevelRule.name}> Rule.\n has ${options.alternation.definition.length + 1} alternatives.`;
5591 return errMsg;
5592 },
5593 buildLeftRecursionError(options) {
5594 const ruleName = options.topLevelRule.name;
5595 const pathNames = (0,map/* default */.Z)(options.leftRecursionPath, (currRule) => currRule.name);
5596 const leftRecursivePath = `${ruleName} --> ${pathNames
5597 .concat([ruleName])
5598 .join(" --> ")}`;
5599 const errMsg = `Left Recursion found in grammar.\n` +
5600 `rule: <${ruleName}> can be invoked from itself (directly or indirectly)\n` +
5601 `without consuming any Tokens. The grammar path that causes this is: \n ${leftRecursivePath}\n` +
5602 ` To fix this refactor your grammar to remove the left recursion.\n` +
5603 `see: https://en.wikipedia.org/wiki/LL_parser#Left_factoring.`;
5604 return errMsg;
5605 },
5606 // TODO: remove - `errors_public` from nyc.config.js exclude
5607 // once this method is fully removed from this file
5608 buildInvalidRuleNameError(options) {
5609 /* istanbul ignore next */
5610 return "deprecated";
5611 },
5612 buildDuplicateRuleNameError(options) {
5613 let ruleName;
5614 if (options.topLevelRule instanceof Rule) {
5615 ruleName = options.topLevelRule.name;
5616 }
5617 else {
5618 ruleName = options.topLevelRule;
5619 }
5620 const errMsg = `Duplicate definition, rule: ->${ruleName}<- is already defined in the grammar: ->${options.grammarName}<-`;
5621 return errMsg;
5622 },
5623 };
5624 //# sourceMappingURL=errors_public.js.map
5625 ;// CONCATENATED MODULE: ../node_modules/@chevrotain/gast/lib/src/visitor.js
5626
5627 class GAstVisitor {
5628 visit(node) {
5629 const nodeAny = node;
5630 switch (nodeAny.constructor) {
5631 case NonTerminal:
5632 return this.visitNonTerminal(nodeAny);
5633 case Alternative:
5634 return this.visitAlternative(nodeAny);
5635 case Option:
5636 return this.visitOption(nodeAny);
5637 case RepetitionMandatory:
5638 return this.visitRepetitionMandatory(nodeAny);
5639 case RepetitionMandatoryWithSeparator:
5640 return this.visitRepetitionMandatoryWithSeparator(nodeAny);
5641 case RepetitionWithSeparator:
5642 return this.visitRepetitionWithSeparator(nodeAny);
5643 case Repetition:
5644 return this.visitRepetition(nodeAny);
5645 case Alternation:
5646 return this.visitAlternation(nodeAny);
5647 case Terminal:
5648 return this.visitTerminal(nodeAny);
5649 case Rule:
5650 return this.visitRule(nodeAny);
5651 /* c8 ignore next 2 */
5652 default:
5653 throw Error("non exhaustive match");
5654 }
5655 }
5656 /* c8 ignore next */
5657 visitNonTerminal(node) { }
5658 /* c8 ignore next */
5659 visitAlternative(node) { }
5660 /* c8 ignore next */
5661 visitOption(node) { }
5662 /* c8 ignore next */
5663 visitRepetition(node) { }
5664 /* c8 ignore next */
5665 visitRepetitionMandatory(node) { }
5666 /* c8 ignore next 3 */
5667 visitRepetitionMandatoryWithSeparator(node) { }
5668 /* c8 ignore next */
5669 visitRepetitionWithSeparator(node) { }
5670 /* c8 ignore next */
5671 visitAlternation(node) { }
5672 /* c8 ignore next */
5673 visitTerminal(node) { }
5674 /* c8 ignore next */
5675 visitRule(node) { }
5676 }
5677 //# sourceMappingURL=visitor.js.map
5678 ;// CONCATENATED MODULE: ../node_modules/chevrotain/lib/src/parse/grammar/resolver.js
5679
5680
5681
5682 function resolveGrammar(topLevels, errMsgProvider) {
5683 const refResolver = new GastRefResolverVisitor(topLevels, errMsgProvider);
5684 refResolver.resolveRefs();
5685 return refResolver.errors;
5686 }
5687 class GastRefResolverVisitor extends GAstVisitor {
5688 constructor(nameToTopRule, errMsgProvider) {
5689 super();
5690 this.nameToTopRule = nameToTopRule;
5691 this.errMsgProvider = errMsgProvider;
5692 this.errors = [];
5693 }
5694 resolveRefs() {
5695 (0,forEach/* default */.Z)((0,values/* default */.Z)(this.nameToTopRule), (prod) => {
5696 this.currTopLevel = prod;
5697 prod.accept(this);
5698 });
5699 }
5700 visitNonTerminal(node) {
5701 const ref = this.nameToTopRule[node.nonTerminalName];
5702 if (!ref) {
5703 const msg = this.errMsgProvider.buildRuleNotFoundError(this.currTopLevel, node);
5704 this.errors.push({
5705 message: msg,
5706 type: ParserDefinitionErrorType.UNRESOLVED_SUBRULE_REF,
5707 ruleName: this.currTopLevel.name,
5708 unresolvedRefName: node.nonTerminalName,
5709 });
5710 }
5711 else {
5712 node.referencedRule = ref;
5713 }
5714 }
5715 }
5716 //# sourceMappingURL=resolver.js.map
5717 // EXTERNAL MODULE: ../node_modules/lodash-es/flatMap.js
5718 var flatMap = __webpack_require__(34134);
5719 // EXTERNAL MODULE: ../node_modules/lodash-es/_baseAssignValue.js
5720 var _baseAssignValue = __webpack_require__(93586);
5721 ;// CONCATENATED MODULE: ../node_modules/lodash-es/_arrayAggregator.js
5722 /**
5723 * A specialized version of `baseAggregator` for arrays.
5724 *
5725 * @private
5726 * @param {Array} [array] The array to iterate over.
5727 * @param {Function} setter The function to set `accumulator` values.
5728 * @param {Function} iteratee The iteratee to transform keys.
5729 * @param {Object} accumulator The initial aggregated object.
5730 * @returns {Function} Returns `accumulator`.
5731 */
5732 function arrayAggregator(array, setter, iteratee, accumulator) {
5733 var index = -1,
5734 length = array == null ? 0 : array.length;
5735
5736 while (++index < length) {
5737 var value = array[index];
5738 setter(accumulator, value, iteratee(value), array);
5739 }
5740 return accumulator;
5741 }
5742
5743 /* harmony default export */ const _arrayAggregator = (arrayAggregator);
5744
5745 ;// CONCATENATED MODULE: ../node_modules/lodash-es/_baseAggregator.js
5746
5747
5748 /**
5749 * Aggregates elements of `collection` on `accumulator` with keys transformed
5750 * by `iteratee` and values set by `setter`.
5751 *
5752 * @private
5753 * @param {Array|Object} collection The collection to iterate over.
5754 * @param {Function} setter The function to set `accumulator` values.
5755 * @param {Function} iteratee The iteratee to transform keys.
5756 * @param {Object} accumulator The initial aggregated object.
5757 * @returns {Function} Returns `accumulator`.
5758 */
5759 function baseAggregator(collection, setter, iteratee, accumulator) {
5760 (0,_baseEach/* default */.Z)(collection, function(value, key, collection) {
5761 setter(accumulator, value, iteratee(value), collection);
5762 });
5763 return accumulator;
5764 }
5765
5766 /* harmony default export */ const _baseAggregator = (baseAggregator);
5767
5768 ;// CONCATENATED MODULE: ../node_modules/lodash-es/_createAggregator.js
5769
5770
5771
5772
5773
5774 /**
5775 * Creates a function like `_.groupBy`.
5776 *
5777 * @private
5778 * @param {Function} setter The function to set accumulator values.
5779 * @param {Function} [initializer] The accumulator object initializer.
5780 * @returns {Function} Returns the new aggregator function.
5781 */
5782 function createAggregator(setter, initializer) {
5783 return function(collection, iteratee) {
5784 var func = (0,isArray/* default */.Z)(collection) ? _arrayAggregator : _baseAggregator,
5785 accumulator = initializer ? initializer() : {};
5786
5787 return func(collection, setter, (0,_baseIteratee/* default */.Z)(iteratee, 2), accumulator);
5788 };
5789 }
5790
5791 /* harmony default export */ const _createAggregator = (createAggregator);
5792
5793 ;// CONCATENATED MODULE: ../node_modules/lodash-es/groupBy.js
5794
5795
5796
5797 /** Used for built-in method references. */
5798 var groupBy_objectProto = Object.prototype;
5799
5800 /** Used to check objects for own properties. */
5801 var groupBy_hasOwnProperty = groupBy_objectProto.hasOwnProperty;
5802
5803 /**
5804 * Creates an object composed of keys generated from the results of running
5805 * each element of `collection` thru `iteratee`. The order of grouped values
5806 * is determined by the order they occur in `collection`. The corresponding
5807 * value of each key is an array of elements responsible for generating the
5808 * key. The iteratee is invoked with one argument: (value).
5809 *
5810 * @static
5811 * @memberOf _
5812 * @since 0.1.0
5813 * @category Collection
5814 * @param {Array|Object} collection The collection to iterate over.
5815 * @param {Function} [iteratee=_.identity] The iteratee to transform keys.
5816 * @returns {Object} Returns the composed aggregate object.
5817 * @example
5818 *
5819 * _.groupBy([6.1, 4.2, 6.3], Math.floor);
5820 * // => { '4': [4.2], '6': [6.1, 6.3] }
5821 *
5822 * // The `_.property` iteratee shorthand.
5823 * _.groupBy(['one', 'two', 'three'], 'length');
5824 * // => { '3': ['one', 'two'], '5': ['three'] }
5825 */
5826 var groupBy = _createAggregator(function(result, value, key) {
5827 if (groupBy_hasOwnProperty.call(result, key)) {
5828 result[key].push(value);
5829 } else {
5830 (0,_baseAssignValue/* default */.Z)(result, key, [value]);
5831 }
5832 });
5833
5834 /* harmony default export */ const lodash_es_groupBy = (groupBy);
5835
5836 ;// CONCATENATED MODULE: ../node_modules/lodash-es/dropRight.js
5837
5838
5839
5840 /**
5841 * Creates a slice of `array` with `n` elements dropped from the end.
5842 *
5843 * @static
5844 * @memberOf _
5845 * @since 3.0.0
5846 * @category Array
5847 * @param {Array} array The array to query.
5848 * @param {number} [n=1] The number of elements to drop.
5849 * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
5850 * @returns {Array} Returns the slice of `array`.
5851 * @example
5852 *
5853 * _.dropRight([1, 2, 3]);
5854 * // => [1, 2]
5855 *
5856 * _.dropRight([1, 2, 3], 2);
5857 * // => [1]
5858 *
5859 * _.dropRight([1, 2, 3], 5);
5860 * // => []
5861 *
5862 * _.dropRight([1, 2, 3], 0);
5863 * // => [1, 2, 3]
5864 */
5865 function dropRight(array, n, guard) {
5866 var length = array == null ? 0 : array.length;
5867 if (!length) {
5868 return [];
5869 }
5870 n = (guard || n === undefined) ? 1 : (0,toInteger/* default */.Z)(n);
5871 n = length - n;
5872 return _baseSlice(array, 0, n < 0 ? 0 : n);
5873 }
5874
5875 /* harmony default export */ const lodash_es_dropRight = (dropRight);
5876
5877 ;// CONCATENATED MODULE: ../node_modules/chevrotain/lib/src/parse/grammar/interpreter.js
5878
5879
5880
5881
5882 class AbstractNextPossibleTokensWalker extends RestWalker {
5883 constructor(topProd, path) {
5884 super();
5885 this.topProd = topProd;
5886 this.path = path;
5887 this.possibleTokTypes = [];
5888 this.nextProductionName = "";
5889 this.nextProductionOccurrence = 0;
5890 this.found = false;
5891 this.isAtEndOfPath = false;
5892 }
5893 startWalking() {
5894 this.found = false;
5895 if (this.path.ruleStack[0] !== this.topProd.name) {
5896 throw Error("The path does not start with the walker's top Rule!");
5897 }
5898 // immutable for the win
5899 this.ruleStack = (0,lodash_es_clone/* default */.Z)(this.path.ruleStack).reverse(); // intelij bug requires assertion
5900 this.occurrenceStack = (0,lodash_es_clone/* default */.Z)(this.path.occurrenceStack).reverse(); // intelij bug requires assertion
5901 // already verified that the first production is valid, we now seek the 2nd production
5902 this.ruleStack.pop();
5903 this.occurrenceStack.pop();
5904 this.updateExpectedNext();
5905 this.walk(this.topProd);
5906 return this.possibleTokTypes;
5907 }
5908 walk(prod, prevRest = []) {
5909 // stop scanning once we found the path
5910 if (!this.found) {
5911 super.walk(prod, prevRest);
5912 }
5913 }
5914 walkProdRef(refProd, currRest, prevRest) {
5915 // found the next production, need to keep walking in it
5916 if (refProd.referencedRule.name === this.nextProductionName &&
5917 refProd.idx === this.nextProductionOccurrence) {
5918 const fullRest = currRest.concat(prevRest);
5919 this.updateExpectedNext();
5920 this.walk(refProd.referencedRule, fullRest);
5921 }
5922 }
5923 updateExpectedNext() {
5924 // need to consume the Terminal
5925 if ((0,isEmpty/* default */.Z)(this.ruleStack)) {
5926 // must reset nextProductionXXX to avoid walking down another Top Level production while what we are
5927 // really seeking is the last Terminal...
5928 this.nextProductionName = "";
5929 this.nextProductionOccurrence = 0;
5930 this.isAtEndOfPath = true;
5931 }
5932 else {
5933 this.nextProductionName = this.ruleStack.pop();
5934 this.nextProductionOccurrence = this.occurrenceStack.pop();
5935 }
5936 }
5937 }
5938 class NextAfterTokenWalker extends AbstractNextPossibleTokensWalker {
5939 constructor(topProd, path) {
5940 super(topProd, path);
5941 this.path = path;
5942 this.nextTerminalName = "";
5943 this.nextTerminalOccurrence = 0;
5944 this.nextTerminalName = this.path.lastTok.name;
5945 this.nextTerminalOccurrence = this.path.lastTokOccurrence;
5946 }
5947 walkTerminal(terminal, currRest, prevRest) {
5948 if (this.isAtEndOfPath &&
5949 terminal.terminalType.name === this.nextTerminalName &&
5950 terminal.idx === this.nextTerminalOccurrence &&
5951 !this.found) {
5952 const fullRest = currRest.concat(prevRest);
5953 const restProd = new Alternative({ definition: fullRest });
5954 this.possibleTokTypes = first(restProd);
5955 this.found = true;
5956 }
5957 }
5958 }
5959 /**
5960 * This walker only "walks" a single "TOP" level in the Grammar Ast, this means
5961 * it never "follows" production refs
5962 */
5963 class AbstractNextTerminalAfterProductionWalker extends RestWalker {
5964 constructor(topRule, occurrence) {
5965 super();
5966 this.topRule = topRule;
5967 this.occurrence = occurrence;
5968 this.result = {
5969 token: undefined,
5970 occurrence: undefined,
5971 isEndOfRule: undefined,
5972 };
5973 }
5974 startWalking() {
5975 this.walk(this.topRule);
5976 return this.result;
5977 }
5978 }
5979 class NextTerminalAfterManyWalker extends AbstractNextTerminalAfterProductionWalker {
5980 walkMany(manyProd, currRest, prevRest) {
5981 if (manyProd.idx === this.occurrence) {
5982 const firstAfterMany = lodash_es_head(currRest.concat(prevRest));
5983 this.result.isEndOfRule = firstAfterMany === undefined;
5984 if (firstAfterMany instanceof Terminal) {
5985 this.result.token = firstAfterMany.terminalType;
5986 this.result.occurrence = firstAfterMany.idx;
5987 }
5988 }
5989 else {
5990 super.walkMany(manyProd, currRest, prevRest);
5991 }
5992 }
5993 }
5994 class NextTerminalAfterManySepWalker extends AbstractNextTerminalAfterProductionWalker {
5995 walkManySep(manySepProd, currRest, prevRest) {
5996 if (manySepProd.idx === this.occurrence) {
5997 const firstAfterManySep = lodash_es_head(currRest.concat(prevRest));
5998 this.result.isEndOfRule = firstAfterManySep === undefined;
5999 if (firstAfterManySep instanceof Terminal) {
6000 this.result.token = firstAfterManySep.terminalType;
6001 this.result.occurrence = firstAfterManySep.idx;
6002 }
6003 }
6004 else {
6005 super.walkManySep(manySepProd, currRest, prevRest);
6006 }
6007 }
6008 }
6009 class NextTerminalAfterAtLeastOneWalker extends AbstractNextTerminalAfterProductionWalker {
6010 walkAtLeastOne(atLeastOneProd, currRest, prevRest) {
6011 if (atLeastOneProd.idx === this.occurrence) {
6012 const firstAfterAtLeastOne = lodash_es_head(currRest.concat(prevRest));
6013 this.result.isEndOfRule = firstAfterAtLeastOne === undefined;
6014 if (firstAfterAtLeastOne instanceof Terminal) {
6015 this.result.token = firstAfterAtLeastOne.terminalType;
6016 this.result.occurrence = firstAfterAtLeastOne.idx;
6017 }
6018 }
6019 else {
6020 super.walkAtLeastOne(atLeastOneProd, currRest, prevRest);
6021 }
6022 }
6023 }
6024 // TODO: reduce code duplication in the AfterWalkers
6025 class NextTerminalAfterAtLeastOneSepWalker extends AbstractNextTerminalAfterProductionWalker {
6026 walkAtLeastOneSep(atleastOneSepProd, currRest, prevRest) {
6027 if (atleastOneSepProd.idx === this.occurrence) {
6028 const firstAfterfirstAfterAtLeastOneSep = lodash_es_head(currRest.concat(prevRest));
6029 this.result.isEndOfRule = firstAfterfirstAfterAtLeastOneSep === undefined;
6030 if (firstAfterfirstAfterAtLeastOneSep instanceof Terminal) {
6031 this.result.token = firstAfterfirstAfterAtLeastOneSep.terminalType;
6032 this.result.occurrence = firstAfterfirstAfterAtLeastOneSep.idx;
6033 }
6034 }
6035 else {
6036 super.walkAtLeastOneSep(atleastOneSepProd, currRest, prevRest);
6037 }
6038 }
6039 }
6040 function possiblePathsFrom(targetDef, maxLength, currPath = []) {
6041 // avoid side effects
6042 currPath = (0,lodash_es_clone/* default */.Z)(currPath);
6043 let result = [];
6044 let i = 0;
6045 // TODO: avoid inner funcs
6046 function remainingPathWith(nextDef) {
6047 return nextDef.concat(lodash_es_drop(targetDef, i + 1));
6048 }
6049 // TODO: avoid inner funcs
6050 function getAlternativesForProd(definition) {
6051 const alternatives = possiblePathsFrom(remainingPathWith(definition), maxLength, currPath);
6052 return result.concat(alternatives);
6053 }
6054 /**
6055 * Mandatory productions will halt the loop as the paths computed from their recursive calls will already contain the
6056 * following (rest) of the targetDef.
6057 *
6058 * For optional productions (Option/Repetition/...) the loop will continue to represent the paths that do not include the
6059 * the optional production.
6060 */
6061 while (currPath.length < maxLength && i < targetDef.length) {
6062 const prod = targetDef[i];
6063 /* istanbul ignore else */
6064 if (prod instanceof Alternative) {
6065 return getAlternativesForProd(prod.definition);
6066 }
6067 else if (prod instanceof NonTerminal) {
6068 return getAlternativesForProd(prod.definition);
6069 }
6070 else if (prod instanceof Option) {
6071 result = getAlternativesForProd(prod.definition);
6072 }
6073 else if (prod instanceof RepetitionMandatory) {
6074 const newDef = prod.definition.concat([
6075 new Repetition({
6076 definition: prod.definition,
6077 }),
6078 ]);
6079 return getAlternativesForProd(newDef);
6080 }
6081 else if (prod instanceof RepetitionMandatoryWithSeparator) {
6082 const newDef = [
6083 new Alternative({ definition: prod.definition }),
6084 new Repetition({
6085 definition: [new Terminal({ terminalType: prod.separator })].concat(prod.definition),
6086 }),
6087 ];
6088 return getAlternativesForProd(newDef);
6089 }
6090 else if (prod instanceof RepetitionWithSeparator) {
6091 const newDef = prod.definition.concat([
6092 new Repetition({
6093 definition: [new Terminal({ terminalType: prod.separator })].concat(prod.definition),
6094 }),
6095 ]);
6096 result = getAlternativesForProd(newDef);
6097 }
6098 else if (prod instanceof Repetition) {
6099 const newDef = prod.definition.concat([
6100 new Repetition({
6101 definition: prod.definition,
6102 }),
6103 ]);
6104 result = getAlternativesForProd(newDef);
6105 }
6106 else if (prod instanceof Alternation) {
6107 (0,forEach/* default */.Z)(prod.definition, (currAlt) => {
6108 // TODO: this is a limited check for empty alternatives
6109 // It would prevent a common case of infinite loops during parser initialization.
6110 // However **in-directly** empty alternatives may still cause issues.
6111 if ((0,isEmpty/* default */.Z)(currAlt.definition) === false) {
6112 result = getAlternativesForProd(currAlt.definition);
6113 }
6114 });
6115 return result;
6116 }
6117 else if (prod instanceof Terminal) {
6118 currPath.push(prod.terminalType);
6119 }
6120 else {
6121 throw Error("non exhaustive match");
6122 }
6123 i++;
6124 }
6125 result.push({
6126 partialPath: currPath,
6127 suffixDef: lodash_es_drop(targetDef, i),
6128 });
6129 return result;
6130 }
6131 function nextPossibleTokensAfter(initialDef, tokenVector, tokMatcher, maxLookAhead) {
6132 const EXIT_NON_TERMINAL = "EXIT_NONE_TERMINAL";
6133 // to avoid creating a new Array each time.
6134 const EXIT_NON_TERMINAL_ARR = [EXIT_NON_TERMINAL];
6135 const EXIT_ALTERNATIVE = "EXIT_ALTERNATIVE";
6136 let foundCompletePath = false;
6137 const tokenVectorLength = tokenVector.length;
6138 const minimalAlternativesIndex = tokenVectorLength - maxLookAhead - 1;
6139 const result = [];
6140 const possiblePaths = [];
6141 possiblePaths.push({
6142 idx: -1,
6143 def: initialDef,
6144 ruleStack: [],
6145 occurrenceStack: [],
6146 });
6147 while (!(0,isEmpty/* default */.Z)(possiblePaths)) {
6148 const currPath = possiblePaths.pop();
6149 // skip alternatives if no more results can be found (assuming deterministic grammar with fixed lookahead)
6150 if (currPath === EXIT_ALTERNATIVE) {
6151 if (foundCompletePath &&
6152 (0,last/* default */.Z)(possiblePaths).idx <= minimalAlternativesIndex) {
6153 // remove irrelevant alternative
6154 possiblePaths.pop();
6155 }
6156 continue;
6157 }
6158 const currDef = currPath.def;
6159 const currIdx = currPath.idx;
6160 const currRuleStack = currPath.ruleStack;
6161 const currOccurrenceStack = currPath.occurrenceStack;
6162 // For Example: an empty path could exist in a valid grammar in the case of an EMPTY_ALT
6163 if ((0,isEmpty/* default */.Z)(currDef)) {
6164 continue;
6165 }
6166 const prod = currDef[0];
6167 /* istanbul ignore else */
6168 if (prod === EXIT_NON_TERMINAL) {
6169 const nextPath = {
6170 idx: currIdx,
6171 def: lodash_es_drop(currDef),
6172 ruleStack: lodash_es_dropRight(currRuleStack),
6173 occurrenceStack: lodash_es_dropRight(currOccurrenceStack),
6174 };
6175 possiblePaths.push(nextPath);
6176 }
6177 else if (prod instanceof Terminal) {
6178 /* istanbul ignore else */
6179 if (currIdx < tokenVectorLength - 1) {
6180 const nextIdx = currIdx + 1;
6181 const actualToken = tokenVector[nextIdx];
6182 if (tokMatcher(actualToken, prod.terminalType)) {
6183 const nextPath = {
6184 idx: nextIdx,
6185 def: lodash_es_drop(currDef),
6186 ruleStack: currRuleStack,
6187 occurrenceStack: currOccurrenceStack,
6188 };
6189 possiblePaths.push(nextPath);
6190 }
6191 // end of the line
6192 }
6193 else if (currIdx === tokenVectorLength - 1) {
6194 // IGNORE ABOVE ELSE
6195 result.push({
6196 nextTokenType: prod.terminalType,
6197 nextTokenOccurrence: prod.idx,
6198 ruleStack: currRuleStack,
6199 occurrenceStack: currOccurrenceStack,
6200 });
6201 foundCompletePath = true;
6202 }
6203 else {
6204 throw Error("non exhaustive match");
6205 }
6206 }
6207 else if (prod instanceof NonTerminal) {
6208 const newRuleStack = (0,lodash_es_clone/* default */.Z)(currRuleStack);
6209 newRuleStack.push(prod.nonTerminalName);
6210 const newOccurrenceStack = (0,lodash_es_clone/* default */.Z)(currOccurrenceStack);
6211 newOccurrenceStack.push(prod.idx);
6212 const nextPath = {
6213 idx: currIdx,
6214 def: prod.definition.concat(EXIT_NON_TERMINAL_ARR, lodash_es_drop(currDef)),
6215 ruleStack: newRuleStack,
6216 occurrenceStack: newOccurrenceStack,
6217 };
6218 possiblePaths.push(nextPath);
6219 }
6220 else if (prod instanceof Option) {
6221 // the order of alternatives is meaningful, FILO (Last path will be traversed first).
6222 const nextPathWithout = {
6223 idx: currIdx,
6224 def: lodash_es_drop(currDef),
6225 ruleStack: currRuleStack,
6226 occurrenceStack: currOccurrenceStack,
6227 };
6228 possiblePaths.push(nextPathWithout);
6229 // required marker to avoid backtracking paths whose higher priority alternatives already matched
6230 possiblePaths.push(EXIT_ALTERNATIVE);
6231 const nextPathWith = {
6232 idx: currIdx,
6233 def: prod.definition.concat(lodash_es_drop(currDef)),
6234 ruleStack: currRuleStack,
6235 occurrenceStack: currOccurrenceStack,
6236 };
6237 possiblePaths.push(nextPathWith);
6238 }
6239 else if (prod instanceof RepetitionMandatory) {
6240 // TODO:(THE NEW operators here take a while...) (convert once?)
6241 const secondIteration = new Repetition({
6242 definition: prod.definition,
6243 idx: prod.idx,
6244 });
6245 const nextDef = prod.definition.concat([secondIteration], lodash_es_drop(currDef));
6246 const nextPath = {
6247 idx: currIdx,
6248 def: nextDef,
6249 ruleStack: currRuleStack,
6250 occurrenceStack: currOccurrenceStack,
6251 };
6252 possiblePaths.push(nextPath);
6253 }
6254 else if (prod instanceof RepetitionMandatoryWithSeparator) {
6255 // TODO:(THE NEW operators here take a while...) (convert once?)
6256 const separatorGast = new Terminal({
6257 terminalType: prod.separator,
6258 });
6259 const secondIteration = new Repetition({
6260 definition: [separatorGast].concat(prod.definition),
6261 idx: prod.idx,
6262 });
6263 const nextDef = prod.definition.concat([secondIteration], lodash_es_drop(currDef));
6264 const nextPath = {
6265 idx: currIdx,
6266 def: nextDef,
6267 ruleStack: currRuleStack,
6268 occurrenceStack: currOccurrenceStack,
6269 };
6270 possiblePaths.push(nextPath);
6271 }
6272 else if (prod instanceof RepetitionWithSeparator) {
6273 // the order of alternatives is meaningful, FILO (Last path will be traversed first).
6274 const nextPathWithout = {
6275 idx: currIdx,
6276 def: lodash_es_drop(currDef),
6277 ruleStack: currRuleStack,
6278 occurrenceStack: currOccurrenceStack,
6279 };
6280 possiblePaths.push(nextPathWithout);
6281 // required marker to avoid backtracking paths whose higher priority alternatives already matched
6282 possiblePaths.push(EXIT_ALTERNATIVE);
6283 const separatorGast = new Terminal({
6284 terminalType: prod.separator,
6285 });
6286 const nthRepetition = new Repetition({
6287 definition: [separatorGast].concat(prod.definition),
6288 idx: prod.idx,
6289 });
6290 const nextDef = prod.definition.concat([nthRepetition], lodash_es_drop(currDef));
6291 const nextPathWith = {
6292 idx: currIdx,
6293 def: nextDef,
6294 ruleStack: currRuleStack,
6295 occurrenceStack: currOccurrenceStack,
6296 };
6297 possiblePaths.push(nextPathWith);
6298 }
6299 else if (prod instanceof Repetition) {
6300 // the order of alternatives is meaningful, FILO (Last path will be traversed first).
6301 const nextPathWithout = {
6302 idx: currIdx,
6303 def: lodash_es_drop(currDef),
6304 ruleStack: currRuleStack,
6305 occurrenceStack: currOccurrenceStack,
6306 };
6307 possiblePaths.push(nextPathWithout);
6308 // required marker to avoid backtracking paths whose higher priority alternatives already matched
6309 possiblePaths.push(EXIT_ALTERNATIVE);
6310 // TODO: an empty repetition will cause infinite loops here, will the parser detect this in selfAnalysis?
6311 const nthRepetition = new Repetition({
6312 definition: prod.definition,
6313 idx: prod.idx,
6314 });
6315 const nextDef = prod.definition.concat([nthRepetition], lodash_es_drop(currDef));
6316 const nextPathWith = {
6317 idx: currIdx,
6318 def: nextDef,
6319 ruleStack: currRuleStack,
6320 occurrenceStack: currOccurrenceStack,
6321 };
6322 possiblePaths.push(nextPathWith);
6323 }
6324 else if (prod instanceof Alternation) {
6325 // the order of alternatives is meaningful, FILO (Last path will be traversed first).
6326 for (let i = prod.definition.length - 1; i >= 0; i--) {
6327 const currAlt = prod.definition[i];
6328 const currAltPath = {
6329 idx: currIdx,
6330 def: currAlt.definition.concat(lodash_es_drop(currDef)),
6331 ruleStack: currRuleStack,
6332 occurrenceStack: currOccurrenceStack,
6333 };
6334 possiblePaths.push(currAltPath);
6335 possiblePaths.push(EXIT_ALTERNATIVE);
6336 }
6337 }
6338 else if (prod instanceof Alternative) {
6339 possiblePaths.push({
6340 idx: currIdx,
6341 def: prod.definition.concat(lodash_es_drop(currDef)),
6342 ruleStack: currRuleStack,
6343 occurrenceStack: currOccurrenceStack,
6344 });
6345 }
6346 else if (prod instanceof Rule) {
6347 // last because we should only encounter at most a single one of these per invocation.
6348 possiblePaths.push(expandTopLevelRule(prod, currIdx, currRuleStack, currOccurrenceStack));
6349 }
6350 else {
6351 throw Error("non exhaustive match");
6352 }
6353 }
6354 return result;
6355 }
6356 function expandTopLevelRule(topRule, currIdx, currRuleStack, currOccurrenceStack) {
6357 const newRuleStack = (0,lodash_es_clone/* default */.Z)(currRuleStack);
6358 newRuleStack.push(topRule.name);
6359 const newCurrOccurrenceStack = (0,lodash_es_clone/* default */.Z)(currOccurrenceStack);
6360 // top rule is always assumed to have been called with occurrence index 1
6361 newCurrOccurrenceStack.push(1);
6362 return {
6363 idx: currIdx,
6364 def: topRule.definition,
6365 ruleStack: newRuleStack,
6366 occurrenceStack: newCurrOccurrenceStack,
6367 };
6368 }
6369 //# sourceMappingURL=interpreter.js.map
6370 ;// CONCATENATED MODULE: ../node_modules/chevrotain/lib/src/parse/grammar/lookahead.js
6371
6372
6373
6374
6375
6376 var PROD_TYPE;
6377 (function (PROD_TYPE) {
6378 PROD_TYPE[PROD_TYPE["OPTION"] = 0] = "OPTION";
6379 PROD_TYPE[PROD_TYPE["REPETITION"] = 1] = "REPETITION";
6380 PROD_TYPE[PROD_TYPE["REPETITION_MANDATORY"] = 2] = "REPETITION_MANDATORY";
6381 PROD_TYPE[PROD_TYPE["REPETITION_MANDATORY_WITH_SEPARATOR"] = 3] = "REPETITION_MANDATORY_WITH_SEPARATOR";
6382 PROD_TYPE[PROD_TYPE["REPETITION_WITH_SEPARATOR"] = 4] = "REPETITION_WITH_SEPARATOR";
6383 PROD_TYPE[PROD_TYPE["ALTERNATION"] = 5] = "ALTERNATION";
6384 })(PROD_TYPE || (PROD_TYPE = {}));
6385 function getProdType(prod) {
6386 /* istanbul ignore else */
6387 if (prod instanceof Option || prod === "Option") {
6388 return PROD_TYPE.OPTION;
6389 }
6390 else if (prod instanceof Repetition || prod === "Repetition") {
6391 return PROD_TYPE.REPETITION;
6392 }
6393 else if (prod instanceof RepetitionMandatory ||
6394 prod === "RepetitionMandatory") {
6395 return PROD_TYPE.REPETITION_MANDATORY;
6396 }
6397 else if (prod instanceof RepetitionMandatoryWithSeparator ||
6398 prod === "RepetitionMandatoryWithSeparator") {
6399 return PROD_TYPE.REPETITION_MANDATORY_WITH_SEPARATOR;
6400 }
6401 else if (prod instanceof RepetitionWithSeparator ||
6402 prod === "RepetitionWithSeparator") {
6403 return PROD_TYPE.REPETITION_WITH_SEPARATOR;
6404 }
6405 else if (prod instanceof Alternation || prod === "Alternation") {
6406 return PROD_TYPE.ALTERNATION;
6407 }
6408 else {
6409 throw Error("non exhaustive match");
6410 }
6411 }
6412 function getLookaheadPaths(options) {
6413 const { occurrence, rule, prodType, maxLookahead } = options;
6414 const type = getProdType(prodType);
6415 if (type === PROD_TYPE.ALTERNATION) {
6416 return getLookaheadPathsForOr(occurrence, rule, maxLookahead);
6417 }
6418 else {
6419 return getLookaheadPathsForOptionalProd(occurrence, rule, type, maxLookahead);
6420 }
6421 }
6422 function buildLookaheadFuncForOr(occurrence, ruleGrammar, maxLookahead, hasPredicates, dynamicTokensEnabled, laFuncBuilder) {
6423 const lookAheadPaths = getLookaheadPathsForOr(occurrence, ruleGrammar, maxLookahead);
6424 const tokenMatcher = areTokenCategoriesNotUsed(lookAheadPaths)
6425 ? tokenStructuredMatcherNoCategories
6426 : tokenStructuredMatcher;
6427 return laFuncBuilder(lookAheadPaths, hasPredicates, tokenMatcher, dynamicTokensEnabled);
6428 }
6429 /**
6430 * When dealing with an Optional production (OPTION/MANY/2nd iteration of AT_LEAST_ONE/...) we need to compare
6431 * the lookahead "inside" the production and the lookahead immediately "after" it in the same top level rule (context free).
6432 *
6433 * Example: given a production:
6434 * ABC(DE)?DF
6435 *
6436 * The optional '(DE)?' should only be entered if we see 'DE'. a single Token 'D' is not sufficient to distinguish between the two
6437 * alternatives.
6438 *
6439 * @returns A Lookahead function which will return true IFF the parser should parse the Optional production.
6440 */
6441 function buildLookaheadFuncForOptionalProd(occurrence, ruleGrammar, k, dynamicTokensEnabled, prodType, lookaheadBuilder) {
6442 const lookAheadPaths = getLookaheadPathsForOptionalProd(occurrence, ruleGrammar, prodType, k);
6443 const tokenMatcher = areTokenCategoriesNotUsed(lookAheadPaths)
6444 ? tokenStructuredMatcherNoCategories
6445 : tokenStructuredMatcher;
6446 return lookaheadBuilder(lookAheadPaths[0], tokenMatcher, dynamicTokensEnabled);
6447 }
6448 function buildAlternativesLookAheadFunc(alts, hasPredicates, tokenMatcher, dynamicTokensEnabled) {
6449 const numOfAlts = alts.length;
6450 const areAllOneTokenLookahead = lodash_es_every(alts, (currAlt) => {
6451 return lodash_es_every(currAlt, (currPath) => {
6452 return currPath.length === 1;
6453 });
6454 });
6455 // This version takes into account the predicates as well.
6456 if (hasPredicates) {
6457 /**
6458 * @returns {number} - The chosen alternative index
6459 */
6460 return function (orAlts) {
6461 // unfortunately the predicates must be extracted every single time
6462 // as they cannot be cached due to references to parameters(vars) which are no longer valid.
6463 // note that in the common case of no predicates, no cpu time will be wasted on this (see else block)
6464 const predicates = (0,map/* default */.Z)(orAlts, (currAlt) => currAlt.GATE);
6465 for (let t = 0; t < numOfAlts; t++) {
6466 const currAlt = alts[t];
6467 const currNumOfPaths = currAlt.length;
6468 const currPredicate = predicates[t];
6469 if (currPredicate !== undefined && currPredicate.call(this) === false) {
6470 // if the predicate does not match there is no point in checking the paths
6471 continue;
6472 }
6473 nextPath: for (let j = 0; j < currNumOfPaths; j++) {
6474 const currPath = currAlt[j];
6475 const currPathLength = currPath.length;
6476 for (let i = 0; i < currPathLength; i++) {
6477 const nextToken = this.LA(i + 1);
6478 if (tokenMatcher(nextToken, currPath[i]) === false) {
6479 // mismatch in current path
6480 // try the next pth
6481 continue nextPath;
6482 }
6483 }
6484 // found a full path that matches.
6485 // this will also work for an empty ALT as the loop will be skipped
6486 return t;
6487 }
6488 // none of the paths for the current alternative matched
6489 // try the next alternative
6490 }
6491 // none of the alternatives could be matched
6492 return undefined;
6493 };
6494 }
6495 else if (areAllOneTokenLookahead && !dynamicTokensEnabled) {
6496 // optimized (common) case of all the lookaheads paths requiring only
6497 // a single token lookahead. These Optimizations cannot work if dynamically defined Tokens are used.
6498 const singleTokenAlts = (0,map/* default */.Z)(alts, (currAlt) => {
6499 return (0,flatten/* default */.Z)(currAlt);
6500 });
6501 const choiceToAlt = (0,reduce/* default */.Z)(singleTokenAlts, (result, currAlt, idx) => {
6502 (0,forEach/* default */.Z)(currAlt, (currTokType) => {
6503 if (!(0,has/* default */.Z)(result, currTokType.tokenTypeIdx)) {
6504 result[currTokType.tokenTypeIdx] = idx;
6505 }
6506 (0,forEach/* default */.Z)(currTokType.categoryMatches, (currExtendingType) => {
6507 if (!(0,has/* default */.Z)(result, currExtendingType)) {
6508 result[currExtendingType] = idx;
6509 }
6510 });
6511 });
6512 return result;
6513 }, {});
6514 /**
6515 * @returns {number} - The chosen alternative index
6516 */
6517 return function () {
6518 const nextToken = this.LA(1);
6519 return choiceToAlt[nextToken.tokenTypeIdx];
6520 };
6521 }
6522 else {
6523 // optimized lookahead without needing to check the predicates at all.
6524 // this causes code duplication which is intentional to improve performance.
6525 /**
6526 * @returns {number} - The chosen alternative index
6527 */
6528 return function () {
6529 for (let t = 0; t < numOfAlts; t++) {
6530 const currAlt = alts[t];
6531 const currNumOfPaths = currAlt.length;
6532 nextPath: for (let j = 0; j < currNumOfPaths; j++) {
6533 const currPath = currAlt[j];
6534 const currPathLength = currPath.length;
6535 for (let i = 0; i < currPathLength; i++) {
6536 const nextToken = this.LA(i + 1);
6537 if (tokenMatcher(nextToken, currPath[i]) === false) {
6538 // mismatch in current path
6539 // try the next pth
6540 continue nextPath;
6541 }
6542 }
6543 // found a full path that matches.
6544 // this will also work for an empty ALT as the loop will be skipped
6545 return t;
6546 }
6547 // none of the paths for the current alternative matched
6548 // try the next alternative
6549 }
6550 // none of the alternatives could be matched
6551 return undefined;
6552 };
6553 }
6554 }
6555 function buildSingleAlternativeLookaheadFunction(alt, tokenMatcher, dynamicTokensEnabled) {
6556 const areAllOneTokenLookahead = lodash_es_every(alt, (currPath) => {
6557 return currPath.length === 1;
6558 });
6559 const numOfPaths = alt.length;
6560 // optimized (common) case of all the lookaheads paths requiring only
6561 // a single token lookahead.
6562 if (areAllOneTokenLookahead && !dynamicTokensEnabled) {
6563 const singleTokensTypes = (0,flatten/* default */.Z)(alt);
6564 if (singleTokensTypes.length === 1 &&
6565 (0,isEmpty/* default */.Z)(singleTokensTypes[0].categoryMatches)) {
6566 const expectedTokenType = singleTokensTypes[0];
6567 const expectedTokenUniqueKey = expectedTokenType.tokenTypeIdx;
6568 return function () {
6569 return this.LA(1).tokenTypeIdx === expectedTokenUniqueKey;
6570 };
6571 }
6572 else {
6573 const choiceToAlt = (0,reduce/* default */.Z)(singleTokensTypes, (result, currTokType, idx) => {
6574 result[currTokType.tokenTypeIdx] = true;
6575 (0,forEach/* default */.Z)(currTokType.categoryMatches, (currExtendingType) => {
6576 result[currExtendingType] = true;
6577 });
6578 return result;
6579 }, []);
6580 return function () {
6581 const nextToken = this.LA(1);
6582 return choiceToAlt[nextToken.tokenTypeIdx] === true;
6583 };
6584 }
6585 }
6586 else {
6587 return function () {
6588 nextPath: for (let j = 0; j < numOfPaths; j++) {
6589 const currPath = alt[j];
6590 const currPathLength = currPath.length;
6591 for (let i = 0; i < currPathLength; i++) {
6592 const nextToken = this.LA(i + 1);
6593 if (tokenMatcher(nextToken, currPath[i]) === false) {
6594 // mismatch in current path
6595 // try the next pth
6596 continue nextPath;
6597 }
6598 }
6599 // found a full path that matches.
6600 return true;
6601 }
6602 // none of the paths matched
6603 return false;
6604 };
6605 }
6606 }
6607 class RestDefinitionFinderWalker extends RestWalker {
6608 constructor(topProd, targetOccurrence, targetProdType) {
6609 super();
6610 this.topProd = topProd;
6611 this.targetOccurrence = targetOccurrence;
6612 this.targetProdType = targetProdType;
6613 }
6614 startWalking() {
6615 this.walk(this.topProd);
6616 return this.restDef;
6617 }
6618 checkIsTarget(node, expectedProdType, currRest, prevRest) {
6619 if (node.idx === this.targetOccurrence &&
6620 this.targetProdType === expectedProdType) {
6621 this.restDef = currRest.concat(prevRest);
6622 return true;
6623 }
6624 // performance optimization, do not iterate over the entire Grammar ast after we have found the target
6625 return false;
6626 }
6627 walkOption(optionProd, currRest, prevRest) {
6628 if (!this.checkIsTarget(optionProd, PROD_TYPE.OPTION, currRest, prevRest)) {
6629 super.walkOption(optionProd, currRest, prevRest);
6630 }
6631 }
6632 walkAtLeastOne(atLeastOneProd, currRest, prevRest) {
6633 if (!this.checkIsTarget(atLeastOneProd, PROD_TYPE.REPETITION_MANDATORY, currRest, prevRest)) {
6634 super.walkOption(atLeastOneProd, currRest, prevRest);
6635 }
6636 }
6637 walkAtLeastOneSep(atLeastOneSepProd, currRest, prevRest) {
6638 if (!this.checkIsTarget(atLeastOneSepProd, PROD_TYPE.REPETITION_MANDATORY_WITH_SEPARATOR, currRest, prevRest)) {
6639 super.walkOption(atLeastOneSepProd, currRest, prevRest);
6640 }
6641 }
6642 walkMany(manyProd, currRest, prevRest) {
6643 if (!this.checkIsTarget(manyProd, PROD_TYPE.REPETITION, currRest, prevRest)) {
6644 super.walkOption(manyProd, currRest, prevRest);
6645 }
6646 }
6647 walkManySep(manySepProd, currRest, prevRest) {
6648 if (!this.checkIsTarget(manySepProd, PROD_TYPE.REPETITION_WITH_SEPARATOR, currRest, prevRest)) {
6649 super.walkOption(manySepProd, currRest, prevRest);
6650 }
6651 }
6652 }
6653 /**
6654 * Returns the definition of a target production in a top level level rule.
6655 */
6656 class InsideDefinitionFinderVisitor extends GAstVisitor {
6657 constructor(targetOccurrence, targetProdType, targetRef) {
6658 super();
6659 this.targetOccurrence = targetOccurrence;
6660 this.targetProdType = targetProdType;
6661 this.targetRef = targetRef;
6662 this.result = [];
6663 }
6664 checkIsTarget(node, expectedProdName) {
6665 if (node.idx === this.targetOccurrence &&
6666 this.targetProdType === expectedProdName &&
6667 (this.targetRef === undefined || node === this.targetRef)) {
6668 this.result = node.definition;
6669 }
6670 }
6671 visitOption(node) {
6672 this.checkIsTarget(node, PROD_TYPE.OPTION);
6673 }
6674 visitRepetition(node) {
6675 this.checkIsTarget(node, PROD_TYPE.REPETITION);
6676 }
6677 visitRepetitionMandatory(node) {
6678 this.checkIsTarget(node, PROD_TYPE.REPETITION_MANDATORY);
6679 }
6680 visitRepetitionMandatoryWithSeparator(node) {
6681 this.checkIsTarget(node, PROD_TYPE.REPETITION_MANDATORY_WITH_SEPARATOR);
6682 }
6683 visitRepetitionWithSeparator(node) {
6684 this.checkIsTarget(node, PROD_TYPE.REPETITION_WITH_SEPARATOR);
6685 }
6686 visitAlternation(node) {
6687 this.checkIsTarget(node, PROD_TYPE.ALTERNATION);
6688 }
6689 }
6690 function initializeArrayOfArrays(size) {
6691 const result = new Array(size);
6692 for (let i = 0; i < size; i++) {
6693 result[i] = [];
6694 }
6695 return result;
6696 }
6697 /**
6698 * A sort of hash function between a Path in the grammar and a string.
6699 * Note that this returns multiple "hashes" to support the scenario of token categories.
6700 * - A single path with categories may match multiple **actual** paths.
6701 */
6702 function pathToHashKeys(path) {
6703 let keys = [""];
6704 for (let i = 0; i < path.length; i++) {
6705 const tokType = path[i];
6706 const longerKeys = [];
6707 for (let j = 0; j < keys.length; j++) {
6708 const currShorterKey = keys[j];
6709 longerKeys.push(currShorterKey + "_" + tokType.tokenTypeIdx);
6710 for (let t = 0; t < tokType.categoryMatches.length; t++) {
6711 const categoriesKeySuffix = "_" + tokType.categoryMatches[t];
6712 longerKeys.push(currShorterKey + categoriesKeySuffix);
6713 }
6714 }
6715 keys = longerKeys;
6716 }
6717 return keys;
6718 }
6719 /**
6720 * Imperative style due to being called from a hot spot
6721 */
6722 function isUniquePrefixHash(altKnownPathsKeys, searchPathKeys, idx) {
6723 for (let currAltIdx = 0; currAltIdx < altKnownPathsKeys.length; currAltIdx++) {
6724 // We only want to test vs the other alternatives
6725 if (currAltIdx === idx) {
6726 continue;
6727 }
6728 const otherAltKnownPathsKeys = altKnownPathsKeys[currAltIdx];
6729 for (let searchIdx = 0; searchIdx < searchPathKeys.length; searchIdx++) {
6730 const searchKey = searchPathKeys[searchIdx];
6731 if (otherAltKnownPathsKeys[searchKey] === true) {
6732 return false;
6733 }
6734 }
6735 }
6736 // None of the SearchPathKeys were found in any of the other alternatives
6737 return true;
6738 }
6739 function lookAheadSequenceFromAlternatives(altsDefs, k) {
6740 const partialAlts = (0,map/* default */.Z)(altsDefs, (currAlt) => possiblePathsFrom([currAlt], 1));
6741 const finalResult = initializeArrayOfArrays(partialAlts.length);
6742 const altsHashes = (0,map/* default */.Z)(partialAlts, (currAltPaths) => {
6743 const dict = {};
6744 (0,forEach/* default */.Z)(currAltPaths, (item) => {
6745 const keys = pathToHashKeys(item.partialPath);
6746 (0,forEach/* default */.Z)(keys, (currKey) => {
6747 dict[currKey] = true;
6748 });
6749 });
6750 return dict;
6751 });
6752 let newData = partialAlts;
6753 // maxLookahead loop
6754 for (let pathLength = 1; pathLength <= k; pathLength++) {
6755 const currDataset = newData;
6756 newData = initializeArrayOfArrays(currDataset.length);
6757 // alternatives loop
6758 for (let altIdx = 0; altIdx < currDataset.length; altIdx++) {
6759 const currAltPathsAndSuffixes = currDataset[altIdx];
6760 // paths in current alternative loop
6761 for (let currPathIdx = 0; currPathIdx < currAltPathsAndSuffixes.length; currPathIdx++) {
6762 const currPathPrefix = currAltPathsAndSuffixes[currPathIdx].partialPath;
6763 const suffixDef = currAltPathsAndSuffixes[currPathIdx].suffixDef;
6764 const prefixKeys = pathToHashKeys(currPathPrefix);
6765 const isUnique = isUniquePrefixHash(altsHashes, prefixKeys, altIdx);
6766 // End of the line for this path.
6767 if (isUnique || (0,isEmpty/* default */.Z)(suffixDef) || currPathPrefix.length === k) {
6768 const currAltResult = finalResult[altIdx];
6769 // TODO: Can we implement a containsPath using Maps/Dictionaries?
6770 if (containsPath(currAltResult, currPathPrefix) === false) {
6771 currAltResult.push(currPathPrefix);
6772 // Update all new keys for the current path.
6773 for (let j = 0; j < prefixKeys.length; j++) {
6774 const currKey = prefixKeys[j];
6775 altsHashes[altIdx][currKey] = true;
6776 }
6777 }
6778 }
6779 // Expand longer paths
6780 else {
6781 const newPartialPathsAndSuffixes = possiblePathsFrom(suffixDef, pathLength + 1, currPathPrefix);
6782 newData[altIdx] = newData[altIdx].concat(newPartialPathsAndSuffixes);
6783 // Update keys for new known paths
6784 (0,forEach/* default */.Z)(newPartialPathsAndSuffixes, (item) => {
6785 const prefixKeys = pathToHashKeys(item.partialPath);
6786 (0,forEach/* default */.Z)(prefixKeys, (key) => {
6787 altsHashes[altIdx][key] = true;
6788 });
6789 });
6790 }
6791 }
6792 }
6793 }
6794 return finalResult;
6795 }
6796 function getLookaheadPathsForOr(occurrence, ruleGrammar, k, orProd) {
6797 const visitor = new InsideDefinitionFinderVisitor(occurrence, PROD_TYPE.ALTERNATION, orProd);
6798 ruleGrammar.accept(visitor);
6799 return lookAheadSequenceFromAlternatives(visitor.result, k);
6800 }
6801 function getLookaheadPathsForOptionalProd(occurrence, ruleGrammar, prodType, k) {
6802 const insideDefVisitor = new InsideDefinitionFinderVisitor(occurrence, prodType);
6803 ruleGrammar.accept(insideDefVisitor);
6804 const insideDef = insideDefVisitor.result;
6805 const afterDefWalker = new RestDefinitionFinderWalker(ruleGrammar, occurrence, prodType);
6806 const afterDef = afterDefWalker.startWalking();
6807 const insideFlat = new Alternative({ definition: insideDef });
6808 const afterFlat = new Alternative({ definition: afterDef });
6809 return lookAheadSequenceFromAlternatives([insideFlat, afterFlat], k);
6810 }
6811 function containsPath(alternative, searchPath) {
6812 compareOtherPath: for (let i = 0; i < alternative.length; i++) {
6813 const otherPath = alternative[i];
6814 if (otherPath.length !== searchPath.length) {
6815 continue;
6816 }
6817 for (let j = 0; j < otherPath.length; j++) {
6818 const searchTok = searchPath[j];
6819 const otherTok = otherPath[j];
6820 const matchingTokens = searchTok === otherTok ||
6821 otherTok.categoryMatchesMap[searchTok.tokenTypeIdx] !== undefined;
6822 if (matchingTokens === false) {
6823 continue compareOtherPath;
6824 }
6825 }
6826 return true;
6827 }
6828 return false;
6829 }
6830 function isStrictPrefixOfPath(prefix, other) {
6831 return (prefix.length < other.length &&
6832 lodash_es_every(prefix, (tokType, idx) => {
6833 const otherTokType = other[idx];
6834 return (tokType === otherTokType ||
6835 otherTokType.categoryMatchesMap[tokType.tokenTypeIdx]);
6836 }));
6837 }
6838 function areTokenCategoriesNotUsed(lookAheadPaths) {
6839 return lodash_es_every(lookAheadPaths, (singleAltPaths) => lodash_es_every(singleAltPaths, (singlePath) => lodash_es_every(singlePath, (token) => (0,isEmpty/* default */.Z)(token.categoryMatches))));
6840 }
6841 //# sourceMappingURL=lookahead.js.map
6842 ;// CONCATENATED MODULE: ../node_modules/chevrotain/lib/src/parse/grammar/checks.js
6843
6844
6845
6846
6847
6848
6849 function validateLookahead(options) {
6850 const lookaheadValidationErrorMessages = options.lookaheadStrategy.validate({
6851 rules: options.rules,
6852 tokenTypes: options.tokenTypes,
6853 grammarName: options.grammarName,
6854 });
6855 return (0,map/* default */.Z)(lookaheadValidationErrorMessages, (errorMessage) => (Object.assign({ type: ParserDefinitionErrorType.CUSTOM_LOOKAHEAD_VALIDATION }, errorMessage)));
6856 }
6857 function validateGrammar(topLevels, tokenTypes, errMsgProvider, grammarName) {
6858 const duplicateErrors = (0,flatMap/* default */.Z)(topLevels, (currTopLevel) => validateDuplicateProductions(currTopLevel, errMsgProvider));
6859 const termsNamespaceConflictErrors = checkTerminalAndNoneTerminalsNameSpace(topLevels, tokenTypes, errMsgProvider);
6860 const tooManyAltsErrors = (0,flatMap/* default */.Z)(topLevels, (curRule) => validateTooManyAlts(curRule, errMsgProvider));
6861 const duplicateRulesError = (0,flatMap/* default */.Z)(topLevels, (curRule) => validateRuleDoesNotAlreadyExist(curRule, topLevels, grammarName, errMsgProvider));
6862 return duplicateErrors.concat(termsNamespaceConflictErrors, tooManyAltsErrors, duplicateRulesError);
6863 }
6864 function validateDuplicateProductions(topLevelRule, errMsgProvider) {
6865 const collectorVisitor = new OccurrenceValidationCollector();
6866 topLevelRule.accept(collectorVisitor);
6867 const allRuleProductions = collectorVisitor.allProductions;
6868 const productionGroups = lodash_es_groupBy(allRuleProductions, identifyProductionForDuplicates);
6869 const duplicates = lodash_es_pickBy(productionGroups, (currGroup) => {
6870 return currGroup.length > 1;
6871 });
6872 const errors = (0,map/* default */.Z)((0,values/* default */.Z)(duplicates), (currDuplicates) => {
6873 const firstProd = lodash_es_head(currDuplicates);
6874 const msg = errMsgProvider.buildDuplicateFoundError(topLevelRule, currDuplicates);
6875 const dslName = getProductionDslName(firstProd);
6876 const defError = {
6877 message: msg,
6878 type: ParserDefinitionErrorType.DUPLICATE_PRODUCTIONS,
6879 ruleName: topLevelRule.name,
6880 dslName: dslName,
6881 occurrence: firstProd.idx,
6882 };
6883 const param = getExtraProductionArgument(firstProd);
6884 if (param) {
6885 defError.parameter = param;
6886 }
6887 return defError;
6888 });
6889 return errors;
6890 }
6891 function identifyProductionForDuplicates(prod) {
6892 return `${getProductionDslName(prod)}_#_${prod.idx}_#_${getExtraProductionArgument(prod)}`;
6893 }
6894 function getExtraProductionArgument(prod) {
6895 if (prod instanceof Terminal) {
6896 return prod.terminalType.name;
6897 }
6898 else if (prod instanceof NonTerminal) {
6899 return prod.nonTerminalName;
6900 }
6901 else {
6902 return "";
6903 }
6904 }
6905 class OccurrenceValidationCollector extends GAstVisitor {
6906 constructor() {
6907 super(...arguments);
6908 this.allProductions = [];
6909 }
6910 visitNonTerminal(subrule) {
6911 this.allProductions.push(subrule);
6912 }
6913 visitOption(option) {
6914 this.allProductions.push(option);
6915 }
6916 visitRepetitionWithSeparator(manySep) {
6917 this.allProductions.push(manySep);
6918 }
6919 visitRepetitionMandatory(atLeastOne) {
6920 this.allProductions.push(atLeastOne);
6921 }
6922 visitRepetitionMandatoryWithSeparator(atLeastOneSep) {
6923 this.allProductions.push(atLeastOneSep);
6924 }
6925 visitRepetition(many) {
6926 this.allProductions.push(many);
6927 }
6928 visitAlternation(or) {
6929 this.allProductions.push(or);
6930 }
6931 visitTerminal(terminal) {
6932 this.allProductions.push(terminal);
6933 }
6934 }
6935 function validateRuleDoesNotAlreadyExist(rule, allRules, className, errMsgProvider) {
6936 const errors = [];
6937 const occurrences = (0,reduce/* default */.Z)(allRules, (result, curRule) => {
6938 if (curRule.name === rule.name) {
6939 return result + 1;
6940 }
6941 return result;
6942 }, 0);
6943 if (occurrences > 1) {
6944 const errMsg = errMsgProvider.buildDuplicateRuleNameError({
6945 topLevelRule: rule,
6946 grammarName: className,
6947 });
6948 errors.push({
6949 message: errMsg,
6950 type: ParserDefinitionErrorType.DUPLICATE_RULE_NAME,
6951 ruleName: rule.name,
6952 });
6953 }
6954 return errors;
6955 }
6956 // TODO: is there anyway to get only the rule names of rules inherited from the super grammars?
6957 // This is not part of the IGrammarErrorProvider because the validation cannot be performed on
6958 // The grammar structure, only at runtime.
6959 function validateRuleIsOverridden(ruleName, definedRulesNames, className) {
6960 const errors = [];
6961 let errMsg;
6962 if (!lodash_es_includes(definedRulesNames, ruleName)) {
6963 errMsg =
6964 `Invalid rule override, rule: ->${ruleName}<- cannot be overridden in the grammar: ->${className}<-` +
6965 `as it is not defined in any of the super grammars `;
6966 errors.push({
6967 message: errMsg,
6968 type: ParserDefinitionErrorType.INVALID_RULE_OVERRIDE,
6969 ruleName: ruleName,
6970 });
6971 }
6972 return errors;
6973 }
6974 function validateNoLeftRecursion(topRule, currRule, errMsgProvider, path = []) {
6975 const errors = [];
6976 const nextNonTerminals = getFirstNoneTerminal(currRule.definition);
6977 if ((0,isEmpty/* default */.Z)(nextNonTerminals)) {
6978 return [];
6979 }
6980 else {
6981 const ruleName = topRule.name;
6982 const foundLeftRecursion = lodash_es_includes(nextNonTerminals, topRule);
6983 if (foundLeftRecursion) {
6984 errors.push({
6985 message: errMsgProvider.buildLeftRecursionError({
6986 topLevelRule: topRule,
6987 leftRecursionPath: path,
6988 }),
6989 type: ParserDefinitionErrorType.LEFT_RECURSION,
6990 ruleName: ruleName,
6991 });
6992 }
6993 // we are only looking for cyclic paths leading back to the specific topRule
6994 // other cyclic paths are ignored, we still need this difference to avoid infinite loops...
6995 const validNextSteps = lodash_es_difference(nextNonTerminals, path.concat([topRule]));
6996 const errorsFromNextSteps = (0,flatMap/* default */.Z)(validNextSteps, (currRefRule) => {
6997 const newPath = (0,lodash_es_clone/* default */.Z)(path);
6998 newPath.push(currRefRule);
6999 return validateNoLeftRecursion(topRule, currRefRule, errMsgProvider, newPath);
7000 });
7001 return errors.concat(errorsFromNextSteps);
7002 }
7003 }
7004 function getFirstNoneTerminal(definition) {
7005 let result = [];
7006 if ((0,isEmpty/* default */.Z)(definition)) {
7007 return result;
7008 }
7009 const firstProd = lodash_es_head(definition);
7010 /* istanbul ignore else */
7011 if (firstProd instanceof NonTerminal) {
7012 result.push(firstProd.referencedRule);
7013 }
7014 else if (firstProd instanceof Alternative ||
7015 firstProd instanceof Option ||
7016 firstProd instanceof RepetitionMandatory ||
7017 firstProd instanceof RepetitionMandatoryWithSeparator ||
7018 firstProd instanceof RepetitionWithSeparator ||
7019 firstProd instanceof Repetition) {
7020 result = result.concat(getFirstNoneTerminal(firstProd.definition));
7021 }
7022 else if (firstProd instanceof Alternation) {
7023 // each sub definition in alternation is a FLAT
7024 result = (0,flatten/* default */.Z)((0,map/* default */.Z)(firstProd.definition, (currSubDef) => getFirstNoneTerminal(currSubDef.definition)));
7025 }
7026 else if (firstProd instanceof Terminal) {
7027 // nothing to see, move along
7028 }
7029 else {
7030 throw Error("non exhaustive match");
7031 }
7032 const isFirstOptional = isOptionalProd(firstProd);
7033 const hasMore = definition.length > 1;
7034 if (isFirstOptional && hasMore) {
7035 const rest = lodash_es_drop(definition);
7036 return result.concat(getFirstNoneTerminal(rest));
7037 }
7038 else {
7039 return result;
7040 }
7041 }
7042 class OrCollector extends GAstVisitor {
7043 constructor() {
7044 super(...arguments);
7045 this.alternations = [];
7046 }
7047 visitAlternation(node) {
7048 this.alternations.push(node);
7049 }
7050 }
7051 function validateEmptyOrAlternative(topLevelRule, errMsgProvider) {
7052 const orCollector = new OrCollector();
7053 topLevelRule.accept(orCollector);
7054 const ors = orCollector.alternations;
7055 const errors = (0,flatMap/* default */.Z)(ors, (currOr) => {
7056 const exceptLast = lodash_es_dropRight(currOr.definition);
7057 return (0,flatMap/* default */.Z)(exceptLast, (currAlternative, currAltIdx) => {
7058 const possibleFirstInAlt = nextPossibleTokensAfter([currAlternative], [], tokenStructuredMatcher, 1);
7059 if ((0,isEmpty/* default */.Z)(possibleFirstInAlt)) {
7060 return [
7061 {
7062 message: errMsgProvider.buildEmptyAlternationError({
7063 topLevelRule: topLevelRule,
7064 alternation: currOr,
7065 emptyChoiceIdx: currAltIdx,
7066 }),
7067 type: ParserDefinitionErrorType.NONE_LAST_EMPTY_ALT,
7068 ruleName: topLevelRule.name,
7069 occurrence: currOr.idx,
7070 alternative: currAltIdx + 1,
7071 },
7072 ];
7073 }
7074 else {
7075 return [];
7076 }
7077 });
7078 });
7079 return errors;
7080 }
7081 function validateAmbiguousAlternationAlternatives(topLevelRule, globalMaxLookahead, errMsgProvider) {
7082 const orCollector = new OrCollector();
7083 topLevelRule.accept(orCollector);
7084 let ors = orCollector.alternations;
7085 // New Handling of ignoring ambiguities
7086 // - https://github.com/chevrotain/chevrotain/issues/869
7087 ors = lodash_es_reject(ors, (currOr) => currOr.ignoreAmbiguities === true);
7088 const errors = (0,flatMap/* default */.Z)(ors, (currOr) => {
7089 const currOccurrence = currOr.idx;
7090 const actualMaxLookahead = currOr.maxLookahead || globalMaxLookahead;
7091 const alternatives = getLookaheadPathsForOr(currOccurrence, topLevelRule, actualMaxLookahead, currOr);
7092 const altsAmbiguityErrors = checkAlternativesAmbiguities(alternatives, currOr, topLevelRule, errMsgProvider);
7093 const altsPrefixAmbiguityErrors = checkPrefixAlternativesAmbiguities(alternatives, currOr, topLevelRule, errMsgProvider);
7094 return altsAmbiguityErrors.concat(altsPrefixAmbiguityErrors);
7095 });
7096 return errors;
7097 }
7098 class RepetitionCollector extends GAstVisitor {
7099 constructor() {
7100 super(...arguments);
7101 this.allProductions = [];
7102 }
7103 visitRepetitionWithSeparator(manySep) {
7104 this.allProductions.push(manySep);
7105 }
7106 visitRepetitionMandatory(atLeastOne) {
7107 this.allProductions.push(atLeastOne);
7108 }
7109 visitRepetitionMandatoryWithSeparator(atLeastOneSep) {
7110 this.allProductions.push(atLeastOneSep);
7111 }
7112 visitRepetition(many) {
7113 this.allProductions.push(many);
7114 }
7115 }
7116 function validateTooManyAlts(topLevelRule, errMsgProvider) {
7117 const orCollector = new OrCollector();
7118 topLevelRule.accept(orCollector);
7119 const ors = orCollector.alternations;
7120 const errors = (0,flatMap/* default */.Z)(ors, (currOr) => {
7121 if (currOr.definition.length > 255) {
7122 return [
7123 {
7124 message: errMsgProvider.buildTooManyAlternativesError({
7125 topLevelRule: topLevelRule,
7126 alternation: currOr,
7127 }),
7128 type: ParserDefinitionErrorType.TOO_MANY_ALTS,
7129 ruleName: topLevelRule.name,
7130 occurrence: currOr.idx,
7131 },
7132 ];
7133 }
7134 else {
7135 return [];
7136 }
7137 });
7138 return errors;
7139 }
7140 function validateSomeNonEmptyLookaheadPath(topLevelRules, maxLookahead, errMsgProvider) {
7141 const errors = [];
7142 (0,forEach/* default */.Z)(topLevelRules, (currTopRule) => {
7143 const collectorVisitor = new RepetitionCollector();
7144 currTopRule.accept(collectorVisitor);
7145 const allRuleProductions = collectorVisitor.allProductions;
7146 (0,forEach/* default */.Z)(allRuleProductions, (currProd) => {
7147 const prodType = getProdType(currProd);
7148 const actualMaxLookahead = currProd.maxLookahead || maxLookahead;
7149 const currOccurrence = currProd.idx;
7150 const paths = getLookaheadPathsForOptionalProd(currOccurrence, currTopRule, prodType, actualMaxLookahead);
7151 const pathsInsideProduction = paths[0];
7152 if ((0,isEmpty/* default */.Z)((0,flatten/* default */.Z)(pathsInsideProduction))) {
7153 const errMsg = errMsgProvider.buildEmptyRepetitionError({
7154 topLevelRule: currTopRule,
7155 repetition: currProd,
7156 });
7157 errors.push({
7158 message: errMsg,
7159 type: ParserDefinitionErrorType.NO_NON_EMPTY_LOOKAHEAD,
7160 ruleName: currTopRule.name,
7161 });
7162 }
7163 });
7164 });
7165 return errors;
7166 }
7167 function checkAlternativesAmbiguities(alternatives, alternation, rule, errMsgProvider) {
7168 const foundAmbiguousPaths = [];
7169 const identicalAmbiguities = (0,reduce/* default */.Z)(alternatives, (result, currAlt, currAltIdx) => {
7170 // ignore (skip) ambiguities with this alternative
7171 if (alternation.definition[currAltIdx].ignoreAmbiguities === true) {
7172 return result;
7173 }
7174 (0,forEach/* default */.Z)(currAlt, (currPath) => {
7175 const altsCurrPathAppearsIn = [currAltIdx];
7176 (0,forEach/* default */.Z)(alternatives, (currOtherAlt, currOtherAltIdx) => {
7177 if (currAltIdx !== currOtherAltIdx &&
7178 containsPath(currOtherAlt, currPath) &&
7179 // ignore (skip) ambiguities with this "other" alternative
7180 alternation.definition[currOtherAltIdx].ignoreAmbiguities !== true) {
7181 altsCurrPathAppearsIn.push(currOtherAltIdx);
7182 }
7183 });
7184 if (altsCurrPathAppearsIn.length > 1 &&
7185 !containsPath(foundAmbiguousPaths, currPath)) {
7186 foundAmbiguousPaths.push(currPath);
7187 result.push({
7188 alts: altsCurrPathAppearsIn,
7189 path: currPath,
7190 });
7191 }
7192 });
7193 return result;
7194 }, []);
7195 const currErrors = (0,map/* default */.Z)(identicalAmbiguities, (currAmbDescriptor) => {
7196 const ambgIndices = (0,map/* default */.Z)(currAmbDescriptor.alts, (currAltIdx) => currAltIdx + 1);
7197 const currMessage = errMsgProvider.buildAlternationAmbiguityError({
7198 topLevelRule: rule,
7199 alternation: alternation,
7200 ambiguityIndices: ambgIndices,
7201 prefixPath: currAmbDescriptor.path,
7202 });
7203 return {
7204 message: currMessage,
7205 type: ParserDefinitionErrorType.AMBIGUOUS_ALTS,
7206 ruleName: rule.name,
7207 occurrence: alternation.idx,
7208 alternatives: currAmbDescriptor.alts,
7209 };
7210 });
7211 return currErrors;
7212 }
7213 function checkPrefixAlternativesAmbiguities(alternatives, alternation, rule, errMsgProvider) {
7214 // flatten
7215 const pathsAndIndices = (0,reduce/* default */.Z)(alternatives, (result, currAlt, idx) => {
7216 const currPathsAndIdx = (0,map/* default */.Z)(currAlt, (currPath) => {
7217 return { idx: idx, path: currPath };
7218 });
7219 return result.concat(currPathsAndIdx);
7220 }, []);
7221 const errors = lodash_es_compact((0,flatMap/* default */.Z)(pathsAndIndices, (currPathAndIdx) => {
7222 const alternativeGast = alternation.definition[currPathAndIdx.idx];
7223 // ignore (skip) ambiguities with this alternative
7224 if (alternativeGast.ignoreAmbiguities === true) {
7225 return [];
7226 }
7227 const targetIdx = currPathAndIdx.idx;
7228 const targetPath = currPathAndIdx.path;
7229 const prefixAmbiguitiesPathsAndIndices = (0,filter/* default */.Z)(pathsAndIndices, (searchPathAndIdx) => {
7230 // prefix ambiguity can only be created from lower idx (higher priority) path
7231 return (
7232 // ignore (skip) ambiguities with this "other" alternative
7233 alternation.definition[searchPathAndIdx.idx].ignoreAmbiguities !==
7234 true &&
7235 searchPathAndIdx.idx < targetIdx &&
7236 // checking for strict prefix because identical lookaheads
7237 // will be be detected using a different validation.
7238 isStrictPrefixOfPath(searchPathAndIdx.path, targetPath));
7239 });
7240 const currPathPrefixErrors = (0,map/* default */.Z)(prefixAmbiguitiesPathsAndIndices, (currAmbPathAndIdx) => {
7241 const ambgIndices = [currAmbPathAndIdx.idx + 1, targetIdx + 1];
7242 const occurrence = alternation.idx === 0 ? "" : alternation.idx;
7243 const message = errMsgProvider.buildAlternationPrefixAmbiguityError({
7244 topLevelRule: rule,
7245 alternation: alternation,
7246 ambiguityIndices: ambgIndices,
7247 prefixPath: currAmbPathAndIdx.path,
7248 });
7249 return {
7250 message: message,
7251 type: ParserDefinitionErrorType.AMBIGUOUS_PREFIX_ALTS,
7252 ruleName: rule.name,
7253 occurrence: occurrence,
7254 alternatives: ambgIndices,
7255 };
7256 });
7257 return currPathPrefixErrors;
7258 }));
7259 return errors;
7260 }
7261 function checkTerminalAndNoneTerminalsNameSpace(topLevels, tokenTypes, errMsgProvider) {
7262 const errors = [];
7263 const tokenNames = (0,map/* default */.Z)(tokenTypes, (currToken) => currToken.name);
7264 (0,forEach/* default */.Z)(topLevels, (currRule) => {
7265 const currRuleName = currRule.name;
7266 if (lodash_es_includes(tokenNames, currRuleName)) {
7267 const errMsg = errMsgProvider.buildNamespaceConflictError(currRule);
7268 errors.push({
7269 message: errMsg,
7270 type: ParserDefinitionErrorType.CONFLICT_TOKENS_RULES_NAMESPACE,
7271 ruleName: currRuleName,
7272 });
7273 }
7274 });
7275 return errors;
7276 }
7277 //# sourceMappingURL=checks.js.map
7278 ;// CONCATENATED MODULE: ../node_modules/chevrotain/lib/src/parse/grammar/gast/gast_resolver_public.js
7279
7280
7281
7282
7283 function gast_resolver_public_resolveGrammar(options) {
7284 const actualOptions = (0,defaults/* default */.Z)(options, {
7285 errMsgProvider: defaultGrammarResolverErrorProvider,
7286 });
7287 const topRulesTable = {};
7288 (0,forEach/* default */.Z)(options.rules, (rule) => {
7289 topRulesTable[rule.name] = rule;
7290 });
7291 return resolveGrammar(topRulesTable, actualOptions.errMsgProvider);
7292 }
7293 function gast_resolver_public_validateGrammar(options) {
7294 options = (0,defaults/* default */.Z)(options, {
7295 errMsgProvider: defaultGrammarValidatorErrorProvider,
7296 });
7297 return validateGrammar(options.rules, options.tokenTypes, options.errMsgProvider, options.grammarName);
7298 }
7299 //# sourceMappingURL=gast_resolver_public.js.map
7300 ;// CONCATENATED MODULE: ../node_modules/chevrotain/lib/src/parse/exceptions_public.js
7301
7302 const MISMATCHED_TOKEN_EXCEPTION = "MismatchedTokenException";
7303 const NO_VIABLE_ALT_EXCEPTION = "NoViableAltException";
7304 const EARLY_EXIT_EXCEPTION = "EarlyExitException";
7305 const NOT_ALL_INPUT_PARSED_EXCEPTION = "NotAllInputParsedException";
7306 const RECOGNITION_EXCEPTION_NAMES = [
7307 MISMATCHED_TOKEN_EXCEPTION,
7308 NO_VIABLE_ALT_EXCEPTION,
7309 EARLY_EXIT_EXCEPTION,
7310 NOT_ALL_INPUT_PARSED_EXCEPTION,
7311 ];
7312 Object.freeze(RECOGNITION_EXCEPTION_NAMES);
7313 // hacks to bypass no support for custom Errors in javascript/typescript
7314 function isRecognitionException(error) {
7315 // can't do instanceof on hacked custom js exceptions
7316 return lodash_es_includes(RECOGNITION_EXCEPTION_NAMES, error.name);
7317 }
7318 class RecognitionException extends Error {
7319 constructor(message, token) {
7320 super(message);
7321 this.token = token;
7322 this.resyncedTokens = [];
7323 // fix prototype chain when typescript target is ES5
7324 Object.setPrototypeOf(this, new.target.prototype);
7325 /* istanbul ignore next - V8 workaround to remove constructor from stacktrace when typescript target is ES5 */
7326 if (Error.captureStackTrace) {
7327 Error.captureStackTrace(this, this.constructor);
7328 }
7329 }
7330 }
7331 class MismatchedTokenException extends RecognitionException {
7332 constructor(message, token, previousToken) {
7333 super(message, token);
7334 this.previousToken = previousToken;
7335 this.name = MISMATCHED_TOKEN_EXCEPTION;
7336 }
7337 }
7338 class NoViableAltException extends RecognitionException {
7339 constructor(message, token, previousToken) {
7340 super(message, token);
7341 this.previousToken = previousToken;
7342 this.name = NO_VIABLE_ALT_EXCEPTION;
7343 }
7344 }
7345 class NotAllInputParsedException extends RecognitionException {
7346 constructor(message, token) {
7347 super(message, token);
7348 this.name = NOT_ALL_INPUT_PARSED_EXCEPTION;
7349 }
7350 }
7351 class EarlyExitException extends RecognitionException {
7352 constructor(message, token, previousToken) {
7353 super(message, token);
7354 this.previousToken = previousToken;
7355 this.name = EARLY_EXIT_EXCEPTION;
7356 }
7357 }
7358 //# sourceMappingURL=exceptions_public.js.map
7359 ;// CONCATENATED MODULE: ../node_modules/chevrotain/lib/src/parse/parser/traits/recoverable.js
7360
7361
7362
7363
7364
7365 const EOF_FOLLOW_KEY = {};
7366 const IN_RULE_RECOVERY_EXCEPTION = "InRuleRecoveryException";
7367 class InRuleRecoveryException extends Error {
7368 constructor(message) {
7369 super(message);
7370 this.name = IN_RULE_RECOVERY_EXCEPTION;
7371 }
7372 }
7373 /**
7374 * This trait is responsible for the error recovery and fault tolerant logic
7375 */
7376 class Recoverable {
7377 initRecoverable(config) {
7378 this.firstAfterRepMap = {};
7379 this.resyncFollows = {};
7380 this.recoveryEnabled = (0,has/* default */.Z)(config, "recoveryEnabled")
7381 ? config.recoveryEnabled // assumes end user provides the correct config value/type
7382 : DEFAULT_PARSER_CONFIG.recoveryEnabled;
7383 // performance optimization, NOOP will be inlined which
7384 // effectively means that this optional feature does not exist
7385 // when not used.
7386 if (this.recoveryEnabled) {
7387 this.attemptInRepetitionRecovery = attemptInRepetitionRecovery;
7388 }
7389 }
7390 getTokenToInsert(tokType) {
7391 const tokToInsert = createTokenInstance(tokType, "", NaN, NaN, NaN, NaN, NaN, NaN);
7392 tokToInsert.isInsertedInRecovery = true;
7393 return tokToInsert;
7394 }
7395 canTokenTypeBeInsertedInRecovery(tokType) {
7396 return true;
7397 }
7398 canTokenTypeBeDeletedInRecovery(tokType) {
7399 return true;
7400 }
7401 tryInRepetitionRecovery(grammarRule, grammarRuleArgs, lookAheadFunc, expectedTokType) {
7402 // TODO: can the resyncTokenType be cached?
7403 const reSyncTokType = this.findReSyncTokenType();
7404 const savedLexerState = this.exportLexerState();
7405 const resyncedTokens = [];
7406 let passedResyncPoint = false;
7407 const nextTokenWithoutResync = this.LA(1);
7408 let currToken = this.LA(1);
7409 const generateErrorMessage = () => {
7410 const previousToken = this.LA(0);
7411 // we are preemptively re-syncing before an error has been detected, therefor we must reproduce
7412 // the error that would have been thrown
7413 const msg = this.errorMessageProvider.buildMismatchTokenMessage({
7414 expected: expectedTokType,
7415 actual: nextTokenWithoutResync,
7416 previous: previousToken,
7417 ruleName: this.getCurrRuleFullName(),
7418 });
7419 const error = new MismatchedTokenException(msg, nextTokenWithoutResync, this.LA(0));
7420 // the first token here will be the original cause of the error, this is not part of the resyncedTokens property.
7421 error.resyncedTokens = lodash_es_dropRight(resyncedTokens);
7422 this.SAVE_ERROR(error);
7423 };
7424 while (!passedResyncPoint) {
7425 // re-synced to a point where we can safely exit the repetition/
7426 if (this.tokenMatcher(currToken, expectedTokType)) {
7427 generateErrorMessage();
7428 return; // must return here to avoid reverting the inputIdx
7429 }
7430 else if (lookAheadFunc.call(this)) {
7431 // we skipped enough tokens so we can resync right back into another iteration of the repetition grammar rule
7432 generateErrorMessage();
7433 // recursive invocation in other to support multiple re-syncs in the same top level repetition grammar rule
7434 grammarRule.apply(this, grammarRuleArgs);
7435 return; // must return here to avoid reverting the inputIdx
7436 }
7437 else if (this.tokenMatcher(currToken, reSyncTokType)) {
7438 passedResyncPoint = true;
7439 }
7440 else {
7441 currToken = this.SKIP_TOKEN();
7442 this.addToResyncTokens(currToken, resyncedTokens);
7443 }
7444 }
7445 // we were unable to find a CLOSER point to resync inside the Repetition, reset the state.
7446 // The parsing exception we were trying to prevent will happen in the NEXT parsing step. it may be handled by
7447 // "between rules" resync recovery later in the flow.
7448 this.importLexerState(savedLexerState);
7449 }
7450 shouldInRepetitionRecoveryBeTried(expectTokAfterLastMatch, nextTokIdx, notStuck) {
7451 // Edge case of arriving from a MANY repetition which is stuck
7452 // Attempting recovery in this case could cause an infinite loop
7453 if (notStuck === false) {
7454 return false;
7455 }
7456 // no need to recover, next token is what we expect...
7457 if (this.tokenMatcher(this.LA(1), expectTokAfterLastMatch)) {
7458 return false;
7459 }
7460 // error recovery is disabled during backtracking as it can make the parser ignore a valid grammar path
7461 // and prefer some backtracking path that includes recovered errors.
7462 if (this.isBackTracking()) {
7463 return false;
7464 }
7465 // if we can perform inRule recovery (single token insertion or deletion) we always prefer that recovery algorithm
7466 // because if it works, it makes the least amount of changes to the input stream (greedy algorithm)
7467 //noinspection RedundantIfStatementJS
7468 if (this.canPerformInRuleRecovery(expectTokAfterLastMatch, this.getFollowsForInRuleRecovery(expectTokAfterLastMatch, nextTokIdx))) {
7469 return false;
7470 }
7471 return true;
7472 }
7473 // Error Recovery functionality
7474 getFollowsForInRuleRecovery(tokType, tokIdxInRule) {
7475 const grammarPath = this.getCurrentGrammarPath(tokType, tokIdxInRule);
7476 const follows = this.getNextPossibleTokenTypes(grammarPath);
7477 return follows;
7478 }
7479 tryInRuleRecovery(expectedTokType, follows) {
7480 if (this.canRecoverWithSingleTokenInsertion(expectedTokType, follows)) {
7481 const tokToInsert = this.getTokenToInsert(expectedTokType);
7482 return tokToInsert;
7483 }
7484 if (this.canRecoverWithSingleTokenDeletion(expectedTokType)) {
7485 const nextTok = this.SKIP_TOKEN();
7486 this.consumeToken();
7487 return nextTok;
7488 }
7489 throw new InRuleRecoveryException("sad sad panda");
7490 }
7491 canPerformInRuleRecovery(expectedToken, follows) {
7492 return (this.canRecoverWithSingleTokenInsertion(expectedToken, follows) ||
7493 this.canRecoverWithSingleTokenDeletion(expectedToken));
7494 }
7495 canRecoverWithSingleTokenInsertion(expectedTokType, follows) {
7496 if (!this.canTokenTypeBeInsertedInRecovery(expectedTokType)) {
7497 return false;
7498 }
7499 // must know the possible following tokens to perform single token insertion
7500 if ((0,isEmpty/* default */.Z)(follows)) {
7501 return false;
7502 }
7503 const mismatchedTok = this.LA(1);
7504 const isMisMatchedTokInFollows = (0,find/* default */.Z)(follows, (possibleFollowsTokType) => {
7505 return this.tokenMatcher(mismatchedTok, possibleFollowsTokType);
7506 }) !== undefined;
7507 return isMisMatchedTokInFollows;
7508 }
7509 canRecoverWithSingleTokenDeletion(expectedTokType) {
7510 if (!this.canTokenTypeBeDeletedInRecovery(expectedTokType)) {
7511 return false;
7512 }
7513 const isNextTokenWhatIsExpected = this.tokenMatcher(this.LA(2), expectedTokType);
7514 return isNextTokenWhatIsExpected;
7515 }
7516 isInCurrentRuleReSyncSet(tokenTypeIdx) {
7517 const followKey = this.getCurrFollowKey();
7518 const currentRuleReSyncSet = this.getFollowSetFromFollowKey(followKey);
7519 return lodash_es_includes(currentRuleReSyncSet, tokenTypeIdx);
7520 }
7521 findReSyncTokenType() {
7522 const allPossibleReSyncTokTypes = this.flattenFollowSet();
7523 // this loop will always terminate as EOF is always in the follow stack and also always (virtually) in the input
7524 let nextToken = this.LA(1);
7525 let k = 2;
7526 while (true) {
7527 const foundMatch = (0,find/* default */.Z)(allPossibleReSyncTokTypes, (resyncTokType) => {
7528 const canMatch = tokenMatcher(nextToken, resyncTokType);
7529 return canMatch;
7530 });
7531 if (foundMatch !== undefined) {
7532 return foundMatch;
7533 }
7534 nextToken = this.LA(k);
7535 k++;
7536 }
7537 }
7538 getCurrFollowKey() {
7539 // the length is at least one as we always add the ruleName to the stack before invoking the rule.
7540 if (this.RULE_STACK.length === 1) {
7541 return EOF_FOLLOW_KEY;
7542 }
7543 const currRuleShortName = this.getLastExplicitRuleShortName();
7544 const currRuleIdx = this.getLastExplicitRuleOccurrenceIndex();
7545 const prevRuleShortName = this.getPreviousExplicitRuleShortName();
7546 return {
7547 ruleName: this.shortRuleNameToFullName(currRuleShortName),
7548 idxInCallingRule: currRuleIdx,
7549 inRule: this.shortRuleNameToFullName(prevRuleShortName),
7550 };
7551 }
7552 buildFullFollowKeyStack() {
7553 const explicitRuleStack = this.RULE_STACK;
7554 const explicitOccurrenceStack = this.RULE_OCCURRENCE_STACK;
7555 return (0,map/* default */.Z)(explicitRuleStack, (ruleName, idx) => {
7556 if (idx === 0) {
7557 return EOF_FOLLOW_KEY;
7558 }
7559 return {
7560 ruleName: this.shortRuleNameToFullName(ruleName),
7561 idxInCallingRule: explicitOccurrenceStack[idx],
7562 inRule: this.shortRuleNameToFullName(explicitRuleStack[idx - 1]),
7563 };
7564 });
7565 }
7566 flattenFollowSet() {
7567 const followStack = (0,map/* default */.Z)(this.buildFullFollowKeyStack(), (currKey) => {
7568 return this.getFollowSetFromFollowKey(currKey);
7569 });
7570 return (0,flatten/* default */.Z)(followStack);
7571 }
7572 getFollowSetFromFollowKey(followKey) {
7573 if (followKey === EOF_FOLLOW_KEY) {
7574 return [EOF];
7575 }
7576 const followName = followKey.ruleName + followKey.idxInCallingRule + constants_IN + followKey.inRule;
7577 return this.resyncFollows[followName];
7578 }
7579 // It does not make any sense to include a virtual EOF token in the list of resynced tokens
7580 // as EOF does not really exist and thus does not contain any useful information (line/column numbers)
7581 addToResyncTokens(token, resyncTokens) {
7582 if (!this.tokenMatcher(token, EOF)) {
7583 resyncTokens.push(token);
7584 }
7585 return resyncTokens;
7586 }
7587 reSyncTo(tokType) {
7588 const resyncedTokens = [];
7589 let nextTok = this.LA(1);
7590 while (this.tokenMatcher(nextTok, tokType) === false) {
7591 nextTok = this.SKIP_TOKEN();
7592 this.addToResyncTokens(nextTok, resyncedTokens);
7593 }
7594 // the last token is not part of the error.
7595 return lodash_es_dropRight(resyncedTokens);
7596 }
7597 attemptInRepetitionRecovery(prodFunc, args, lookaheadFunc, dslMethodIdx, prodOccurrence, nextToksWalker, notStuck) {
7598 // by default this is a NO-OP
7599 // The actual implementation is with the function(not method) below
7600 }
7601 getCurrentGrammarPath(tokType, tokIdxInRule) {
7602 const pathRuleStack = this.getHumanReadableRuleStack();
7603 const pathOccurrenceStack = (0,lodash_es_clone/* default */.Z)(this.RULE_OCCURRENCE_STACK);
7604 const grammarPath = {
7605 ruleStack: pathRuleStack,
7606 occurrenceStack: pathOccurrenceStack,
7607 lastTok: tokType,
7608 lastTokOccurrence: tokIdxInRule,
7609 };
7610 return grammarPath;
7611 }
7612 getHumanReadableRuleStack() {
7613 return (0,map/* default */.Z)(this.RULE_STACK, (currShortName) => this.shortRuleNameToFullName(currShortName));
7614 }
7615 }
7616 function attemptInRepetitionRecovery(prodFunc, args, lookaheadFunc, dslMethodIdx, prodOccurrence, nextToksWalker, notStuck) {
7617 const key = this.getKeyForAutomaticLookahead(dslMethodIdx, prodOccurrence);
7618 let firstAfterRepInfo = this.firstAfterRepMap[key];
7619 if (firstAfterRepInfo === undefined) {
7620 const currRuleName = this.getCurrRuleFullName();
7621 const ruleGrammar = this.getGAstProductions()[currRuleName];
7622 const walker = new nextToksWalker(ruleGrammar, prodOccurrence);
7623 firstAfterRepInfo = walker.startWalking();
7624 this.firstAfterRepMap[key] = firstAfterRepInfo;
7625 }
7626 let expectTokAfterLastMatch = firstAfterRepInfo.token;
7627 let nextTokIdx = firstAfterRepInfo.occurrence;
7628 const isEndOfRule = firstAfterRepInfo.isEndOfRule;
7629 // special edge case of a TOP most repetition after which the input should END.
7630 // this will force an attempt for inRule recovery in that scenario.
7631 if (this.RULE_STACK.length === 1 &&
7632 isEndOfRule &&
7633 expectTokAfterLastMatch === undefined) {
7634 expectTokAfterLastMatch = EOF;
7635 nextTokIdx = 1;
7636 }
7637 // We don't have anything to re-sync to...
7638 // this condition was extracted from `shouldInRepetitionRecoveryBeTried` to act as a type-guard
7639 if (expectTokAfterLastMatch === undefined || nextTokIdx === undefined) {
7640 return;
7641 }
7642 if (this.shouldInRepetitionRecoveryBeTried(expectTokAfterLastMatch, nextTokIdx, notStuck)) {
7643 // TODO: performance optimization: instead of passing the original args here, we modify
7644 // the args param (or create a new one) and make sure the lookahead func is explicitly provided
7645 // to avoid searching the cache for it once more.
7646 this.tryInRepetitionRecovery(prodFunc, args, lookaheadFunc, expectTokAfterLastMatch);
7647 }
7648 }
7649 //# sourceMappingURL=recoverable.js.map
7650 ;// CONCATENATED MODULE: ../node_modules/chevrotain/lib/src/parse/grammar/keys.js
7651 // Lookahead keys are 32Bit integers in the form
7652 // TTTTTTTT-ZZZZZZZZZZZZ-YYYY-XXXXXXXX
7653 // XXXX -> Occurrence Index bitmap.
7654 // YYYY -> DSL Method Type bitmap.
7655 // ZZZZZZZZZZZZZZZ -> Rule short Index bitmap.
7656 // TTTTTTTTT -> alternation alternative index bitmap
7657 const BITS_FOR_METHOD_TYPE = 4;
7658 const BITS_FOR_OCCURRENCE_IDX = 8;
7659 const BITS_FOR_RULE_IDX = 12;
7660 // TODO: validation, this means that there may at most 2^8 --> 256 alternatives for an alternation.
7661 const BITS_FOR_ALT_IDX = 8;
7662 // short string used as part of mapping keys.
7663 // being short improves the performance when composing KEYS for maps out of these
7664 // The 5 - 8 bits (16 possible values, are reserved for the DSL method indices)
7665 const OR_IDX = 1 << BITS_FOR_OCCURRENCE_IDX;
7666 const OPTION_IDX = 2 << BITS_FOR_OCCURRENCE_IDX;
7667 const MANY_IDX = 3 << BITS_FOR_OCCURRENCE_IDX;
7668 const AT_LEAST_ONE_IDX = 4 << BITS_FOR_OCCURRENCE_IDX;
7669 const MANY_SEP_IDX = 5 << BITS_FOR_OCCURRENCE_IDX;
7670 const AT_LEAST_ONE_SEP_IDX = 6 << BITS_FOR_OCCURRENCE_IDX;
7671 // this actually returns a number, but it is always used as a string (object prop key)
7672 function getKeyForAutomaticLookahead(ruleIdx, dslMethodIdx, occurrence) {
7673 return occurrence | dslMethodIdx | ruleIdx;
7674 }
7675 const BITS_START_FOR_ALT_IDX = 32 - BITS_FOR_ALT_IDX;
7676 //# sourceMappingURL=keys.js.map
7677 ;// CONCATENATED MODULE: ../node_modules/chevrotain/lib/src/parse/grammar/llk_lookahead.js
7678
7679
7680
7681
7682
7683 class LLkLookaheadStrategy {
7684 constructor(options) {
7685 var _a;
7686 this.maxLookahead =
7687 (_a = options === null || options === void 0 ? void 0 : options.maxLookahead) !== null && _a !== void 0 ? _a : DEFAULT_PARSER_CONFIG.maxLookahead;
7688 }
7689 validate(options) {
7690 const leftRecursionErrors = this.validateNoLeftRecursion(options.rules);
7691 if ((0,isEmpty/* default */.Z)(leftRecursionErrors)) {
7692 const emptyAltErrors = this.validateEmptyOrAlternatives(options.rules);
7693 const ambiguousAltsErrors = this.validateAmbiguousAlternationAlternatives(options.rules, this.maxLookahead);
7694 const emptyRepetitionErrors = this.validateSomeNonEmptyLookaheadPath(options.rules, this.maxLookahead);
7695 const allErrors = [
7696 ...leftRecursionErrors,
7697 ...emptyAltErrors,
7698 ...ambiguousAltsErrors,
7699 ...emptyRepetitionErrors,
7700 ];
7701 return allErrors;
7702 }
7703 return leftRecursionErrors;
7704 }
7705 validateNoLeftRecursion(rules) {
7706 return (0,flatMap/* default */.Z)(rules, (currTopRule) => validateNoLeftRecursion(currTopRule, currTopRule, defaultGrammarValidatorErrorProvider));
7707 }
7708 validateEmptyOrAlternatives(rules) {
7709 return (0,flatMap/* default */.Z)(rules, (currTopRule) => validateEmptyOrAlternative(currTopRule, defaultGrammarValidatorErrorProvider));
7710 }
7711 validateAmbiguousAlternationAlternatives(rules, maxLookahead) {
7712 return (0,flatMap/* default */.Z)(rules, (currTopRule) => validateAmbiguousAlternationAlternatives(currTopRule, maxLookahead, defaultGrammarValidatorErrorProvider));
7713 }
7714 validateSomeNonEmptyLookaheadPath(rules, maxLookahead) {
7715 return validateSomeNonEmptyLookaheadPath(rules, maxLookahead, defaultGrammarValidatorErrorProvider);
7716 }
7717 buildLookaheadForAlternation(options) {
7718 return buildLookaheadFuncForOr(options.prodOccurrence, options.rule, options.maxLookahead, options.hasPredicates, options.dynamicTokensEnabled, buildAlternativesLookAheadFunc);
7719 }
7720 buildLookaheadForOptional(options) {
7721 return buildLookaheadFuncForOptionalProd(options.prodOccurrence, options.rule, options.maxLookahead, options.dynamicTokensEnabled, getProdType(options.prodType), buildSingleAlternativeLookaheadFunction);
7722 }
7723 }
7724 //# sourceMappingURL=llk_lookahead.js.map
7725 ;// CONCATENATED MODULE: ../node_modules/chevrotain/lib/src/parse/parser/traits/looksahead.js
7726
7727
7728
7729
7730
7731 /**
7732 * Trait responsible for the lookahead related utilities and optimizations.
7733 */
7734 class LooksAhead {
7735 initLooksAhead(config) {
7736 this.dynamicTokensEnabled = (0,has/* default */.Z)(config, "dynamicTokensEnabled")
7737 ? config.dynamicTokensEnabled // assumes end user provides the correct config value/type
7738 : DEFAULT_PARSER_CONFIG.dynamicTokensEnabled;
7739 this.maxLookahead = (0,has/* default */.Z)(config, "maxLookahead")
7740 ? config.maxLookahead // assumes end user provides the correct config value/type
7741 : DEFAULT_PARSER_CONFIG.maxLookahead;
7742 this.lookaheadStrategy = (0,has/* default */.Z)(config, "lookaheadStrategy")
7743 ? config.lookaheadStrategy // assumes end user provides the correct config value/type
7744 : new LLkLookaheadStrategy({ maxLookahead: this.maxLookahead });
7745 this.lookAheadFuncsCache = new Map();
7746 }
7747 preComputeLookaheadFunctions(rules) {
7748 (0,forEach/* default */.Z)(rules, (currRule) => {
7749 this.TRACE_INIT(`${currRule.name} Rule Lookahead`, () => {
7750 const { alternation, repetition, option, repetitionMandatory, repetitionMandatoryWithSeparator, repetitionWithSeparator, } = collectMethods(currRule);
7751 (0,forEach/* default */.Z)(alternation, (currProd) => {
7752 const prodIdx = currProd.idx === 0 ? "" : currProd.idx;
7753 this.TRACE_INIT(`${getProductionDslName(currProd)}${prodIdx}`, () => {
7754 const laFunc = this.lookaheadStrategy.buildLookaheadForAlternation({
7755 prodOccurrence: currProd.idx,
7756 rule: currRule,
7757 maxLookahead: currProd.maxLookahead || this.maxLookahead,
7758 hasPredicates: currProd.hasPredicates,
7759 dynamicTokensEnabled: this.dynamicTokensEnabled,
7760 });
7761 const key = getKeyForAutomaticLookahead(this.fullRuleNameToShort[currRule.name], OR_IDX, currProd.idx);
7762 this.setLaFuncCache(key, laFunc);
7763 });
7764 });
7765 (0,forEach/* default */.Z)(repetition, (currProd) => {
7766 this.computeLookaheadFunc(currRule, currProd.idx, MANY_IDX, "Repetition", currProd.maxLookahead, getProductionDslName(currProd));
7767 });
7768 (0,forEach/* default */.Z)(option, (currProd) => {
7769 this.computeLookaheadFunc(currRule, currProd.idx, OPTION_IDX, "Option", currProd.maxLookahead, getProductionDslName(currProd));
7770 });
7771 (0,forEach/* default */.Z)(repetitionMandatory, (currProd) => {
7772 this.computeLookaheadFunc(currRule, currProd.idx, AT_LEAST_ONE_IDX, "RepetitionMandatory", currProd.maxLookahead, getProductionDslName(currProd));
7773 });
7774 (0,forEach/* default */.Z)(repetitionMandatoryWithSeparator, (currProd) => {
7775 this.computeLookaheadFunc(currRule, currProd.idx, AT_LEAST_ONE_SEP_IDX, "RepetitionMandatoryWithSeparator", currProd.maxLookahead, getProductionDslName(currProd));
7776 });
7777 (0,forEach/* default */.Z)(repetitionWithSeparator, (currProd) => {
7778 this.computeLookaheadFunc(currRule, currProd.idx, MANY_SEP_IDX, "RepetitionWithSeparator", currProd.maxLookahead, getProductionDslName(currProd));
7779 });
7780 });
7781 });
7782 }
7783 computeLookaheadFunc(rule, prodOccurrence, prodKey, prodType, prodMaxLookahead, dslMethodName) {
7784 this.TRACE_INIT(`${dslMethodName}${prodOccurrence === 0 ? "" : prodOccurrence}`, () => {
7785 const laFunc = this.lookaheadStrategy.buildLookaheadForOptional({
7786 prodOccurrence,
7787 rule,
7788 maxLookahead: prodMaxLookahead || this.maxLookahead,
7789 dynamicTokensEnabled: this.dynamicTokensEnabled,
7790 prodType,
7791 });
7792 const key = getKeyForAutomaticLookahead(this.fullRuleNameToShort[rule.name], prodKey, prodOccurrence);
7793 this.setLaFuncCache(key, laFunc);
7794 });
7795 }
7796 // this actually returns a number, but it is always used as a string (object prop key)
7797 getKeyForAutomaticLookahead(dslMethodIdx, occurrence) {
7798 const currRuleShortName = this.getLastExplicitRuleShortName();
7799 return getKeyForAutomaticLookahead(currRuleShortName, dslMethodIdx, occurrence);
7800 }
7801 getLaFuncFromCache(key) {
7802 return this.lookAheadFuncsCache.get(key);
7803 }
7804 /* istanbul ignore next */
7805 setLaFuncCache(key, value) {
7806 this.lookAheadFuncsCache.set(key, value);
7807 }
7808 }
7809 class DslMethodsCollectorVisitor extends GAstVisitor {
7810 constructor() {
7811 super(...arguments);
7812 this.dslMethods = {
7813 option: [],
7814 alternation: [],
7815 repetition: [],
7816 repetitionWithSeparator: [],
7817 repetitionMandatory: [],
7818 repetitionMandatoryWithSeparator: [],
7819 };
7820 }
7821 reset() {
7822 this.dslMethods = {
7823 option: [],
7824 alternation: [],
7825 repetition: [],
7826 repetitionWithSeparator: [],
7827 repetitionMandatory: [],
7828 repetitionMandatoryWithSeparator: [],
7829 };
7830 }
7831 visitOption(option) {
7832 this.dslMethods.option.push(option);
7833 }
7834 visitRepetitionWithSeparator(manySep) {
7835 this.dslMethods.repetitionWithSeparator.push(manySep);
7836 }
7837 visitRepetitionMandatory(atLeastOne) {
7838 this.dslMethods.repetitionMandatory.push(atLeastOne);
7839 }
7840 visitRepetitionMandatoryWithSeparator(atLeastOneSep) {
7841 this.dslMethods.repetitionMandatoryWithSeparator.push(atLeastOneSep);
7842 }
7843 visitRepetition(many) {
7844 this.dslMethods.repetition.push(many);
7845 }
7846 visitAlternation(or) {
7847 this.dslMethods.alternation.push(or);
7848 }
7849 }
7850 const collectorVisitor = new DslMethodsCollectorVisitor();
7851 function collectMethods(rule) {
7852 collectorVisitor.reset();
7853 rule.accept(collectorVisitor);
7854 const dslMethods = collectorVisitor.dslMethods;
7855 // avoid uncleaned references
7856 collectorVisitor.reset();
7857 return dslMethods;
7858 }
7859 //# sourceMappingURL=looksahead.js.map
7860 ;// CONCATENATED MODULE: ../node_modules/chevrotain/lib/src/parse/cst/cst.js
7861 /**
7862 * This nodeLocation tracking is not efficient and should only be used
7863 * when error recovery is enabled or the Token Vector contains virtual Tokens
7864 * (e.g, Python Indent/Outdent)
7865 * As it executes the calculation for every single terminal/nonTerminal
7866 * and does not rely on the fact the token vector is **sorted**
7867 */
7868 function setNodeLocationOnlyOffset(currNodeLocation, newLocationInfo) {
7869 // First (valid) update for this cst node
7870 if (isNaN(currNodeLocation.startOffset) === true) {
7871 // assumption1: Token location information is either NaN or a valid number
7872 // assumption2: Token location information is fully valid if it exist
7873 // (both start/end offsets exist and are numbers).
7874 currNodeLocation.startOffset = newLocationInfo.startOffset;
7875 currNodeLocation.endOffset = newLocationInfo.endOffset;
7876 }
7877 // Once the startOffset has been updated with a valid number it should never receive
7878 // any farther updates as the Token vector is sorted.
7879 // We still have to check this this condition for every new possible location info
7880 // because with error recovery enabled we may encounter invalid tokens (NaN location props)
7881 else if (currNodeLocation.endOffset < newLocationInfo.endOffset === true) {
7882 currNodeLocation.endOffset = newLocationInfo.endOffset;
7883 }
7884 }
7885 /**
7886 * This nodeLocation tracking is not efficient and should only be used
7887 * when error recovery is enabled or the Token Vector contains virtual Tokens
7888 * (e.g, Python Indent/Outdent)
7889 * As it executes the calculation for every single terminal/nonTerminal
7890 * and does not rely on the fact the token vector is **sorted**
7891 */
7892 function setNodeLocationFull(currNodeLocation, newLocationInfo) {
7893 // First (valid) update for this cst node
7894 if (isNaN(currNodeLocation.startOffset) === true) {
7895 // assumption1: Token location information is either NaN or a valid number
7896 // assumption2: Token location information is fully valid if it exist
7897 // (all start/end props exist and are numbers).
7898 currNodeLocation.startOffset = newLocationInfo.startOffset;
7899 currNodeLocation.startColumn = newLocationInfo.startColumn;
7900 currNodeLocation.startLine = newLocationInfo.startLine;
7901 currNodeLocation.endOffset = newLocationInfo.endOffset;
7902 currNodeLocation.endColumn = newLocationInfo.endColumn;
7903 currNodeLocation.endLine = newLocationInfo.endLine;
7904 }
7905 // Once the start props has been updated with a valid number it should never receive
7906 // any farther updates as the Token vector is sorted.
7907 // We still have to check this this condition for every new possible location info
7908 // because with error recovery enabled we may encounter invalid tokens (NaN location props)
7909 else if (currNodeLocation.endOffset < newLocationInfo.endOffset === true) {
7910 currNodeLocation.endOffset = newLocationInfo.endOffset;
7911 currNodeLocation.endColumn = newLocationInfo.endColumn;
7912 currNodeLocation.endLine = newLocationInfo.endLine;
7913 }
7914 }
7915 function addTerminalToCst(node, token, tokenTypeName) {
7916 if (node.children[tokenTypeName] === undefined) {
7917 node.children[tokenTypeName] = [token];
7918 }
7919 else {
7920 node.children[tokenTypeName].push(token);
7921 }
7922 }
7923 function addNoneTerminalToCst(node, ruleName, ruleResult) {
7924 if (node.children[ruleName] === undefined) {
7925 node.children[ruleName] = [ruleResult];
7926 }
7927 else {
7928 node.children[ruleName].push(ruleResult);
7929 }
7930 }
7931 //# sourceMappingURL=cst.js.map
7932 ;// CONCATENATED MODULE: ../node_modules/chevrotain/lib/src/lang/lang_extensions.js
7933 const NAME = "name";
7934 function defineNameProp(obj, nameValue) {
7935 Object.defineProperty(obj, NAME, {
7936 enumerable: false,
7937 configurable: true,
7938 writable: false,
7939 value: nameValue,
7940 });
7941 }
7942 //# sourceMappingURL=lang_extensions.js.map
7943 ;// CONCATENATED MODULE: ../node_modules/chevrotain/lib/src/parse/cst/cst_visitor.js
7944
7945
7946 function defaultVisit(ctx, param) {
7947 const childrenNames = (0,keys/* default */.Z)(ctx);
7948 const childrenNamesLength = childrenNames.length;
7949 for (let i = 0; i < childrenNamesLength; i++) {
7950 const currChildName = childrenNames[i];
7951 const currChildArray = ctx[currChildName];
7952 const currChildArrayLength = currChildArray.length;
7953 for (let j = 0; j < currChildArrayLength; j++) {
7954 const currChild = currChildArray[j];
7955 // distinction between Tokens Children and CstNode children
7956 if (currChild.tokenTypeIdx === undefined) {
7957 this[currChild.name](currChild.children, param);
7958 }
7959 }
7960 }
7961 // defaultVisit does not support generic out param
7962 }
7963 function createBaseSemanticVisitorConstructor(grammarName, ruleNames) {
7964 const derivedConstructor = function () { };
7965 // can be overwritten according to:
7966 // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/
7967 // name?redirectlocale=en-US&redirectslug=JavaScript%2FReference%2FGlobal_Objects%2FFunction%2Fname
7968 defineNameProp(derivedConstructor, grammarName + "BaseSemantics");
7969 const semanticProto = {
7970 visit: function (cstNode, param) {
7971 // enables writing more concise visitor methods when CstNode has only a single child
7972 if ((0,isArray/* default */.Z)(cstNode)) {
7973 // A CST Node's children dictionary can never have empty arrays as values
7974 // If a key is defined there will be at least one element in the corresponding value array.
7975 cstNode = cstNode[0];
7976 }
7977 // enables passing optional CstNodes concisely.
7978 if ((0,isUndefined/* default */.Z)(cstNode)) {
7979 return undefined;
7980 }
7981 return this[cstNode.name](cstNode.children, param);
7982 },
7983 validateVisitor: function () {
7984 const semanticDefinitionErrors = validateVisitor(this, ruleNames);
7985 if (!(0,isEmpty/* default */.Z)(semanticDefinitionErrors)) {
7986 const errorMessages = (0,map/* default */.Z)(semanticDefinitionErrors, (currDefError) => currDefError.msg);
7987 throw Error(`Errors Detected in CST Visitor <${this.constructor.name}>:\n\t` +
7988 `${errorMessages.join("\n\n").replace(/\n/g, "\n\t")}`);
7989 }
7990 },
7991 };
7992 derivedConstructor.prototype = semanticProto;
7993 derivedConstructor.prototype.constructor = derivedConstructor;
7994 derivedConstructor._RULE_NAMES = ruleNames;
7995 return derivedConstructor;
7996 }
7997 function createBaseVisitorConstructorWithDefaults(grammarName, ruleNames, baseConstructor) {
7998 const derivedConstructor = function () { };
7999 // can be overwritten according to:
8000 // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/
8001 // name?redirectlocale=en-US&redirectslug=JavaScript%2FReference%2FGlobal_Objects%2FFunction%2Fname
8002 defineNameProp(derivedConstructor, grammarName + "BaseSemanticsWithDefaults");
8003 const withDefaultsProto = Object.create(baseConstructor.prototype);
8004 (0,forEach/* default */.Z)(ruleNames, (ruleName) => {
8005 withDefaultsProto[ruleName] = defaultVisit;
8006 });
8007 derivedConstructor.prototype = withDefaultsProto;
8008 derivedConstructor.prototype.constructor = derivedConstructor;
8009 return derivedConstructor;
8010 }
8011 var CstVisitorDefinitionError;
8012 (function (CstVisitorDefinitionError) {
8013 CstVisitorDefinitionError[CstVisitorDefinitionError["REDUNDANT_METHOD"] = 0] = "REDUNDANT_METHOD";
8014 CstVisitorDefinitionError[CstVisitorDefinitionError["MISSING_METHOD"] = 1] = "MISSING_METHOD";
8015 })(CstVisitorDefinitionError || (CstVisitorDefinitionError = {}));
8016 function validateVisitor(visitorInstance, ruleNames) {
8017 const missingErrors = validateMissingCstMethods(visitorInstance, ruleNames);
8018 return missingErrors;
8019 }
8020 function validateMissingCstMethods(visitorInstance, ruleNames) {
8021 const missingRuleNames = (0,filter/* default */.Z)(ruleNames, (currRuleName) => {
8022 return (0,isFunction/* default */.Z)(visitorInstance[currRuleName]) === false;
8023 });
8024 const errors = (0,map/* default */.Z)(missingRuleNames, (currRuleName) => {
8025 return {
8026 msg: `Missing visitor method: <${currRuleName}> on ${(visitorInstance.constructor.name)} CST Visitor.`,
8027 type: CstVisitorDefinitionError.MISSING_METHOD,
8028 methodName: currRuleName,
8029 };
8030 });
8031 return lodash_es_compact(errors);
8032 }
8033 //# sourceMappingURL=cst_visitor.js.map
8034 ;// CONCATENATED MODULE: ../node_modules/chevrotain/lib/src/parse/parser/traits/tree_builder.js
8035
8036
8037
8038
8039 /**
8040 * This trait is responsible for the CST building logic.
8041 */
8042 class TreeBuilder {
8043 initTreeBuilder(config) {
8044 this.CST_STACK = [];
8045 // outputCst is no longer exposed/defined in the pubic API
8046 this.outputCst = config.outputCst;
8047 this.nodeLocationTracking = (0,has/* default */.Z)(config, "nodeLocationTracking")
8048 ? config.nodeLocationTracking // assumes end user provides the correct config value/type
8049 : DEFAULT_PARSER_CONFIG.nodeLocationTracking;
8050 if (!this.outputCst) {
8051 this.cstInvocationStateUpdate = noop/* default */.Z;
8052 this.cstFinallyStateUpdate = noop/* default */.Z;
8053 this.cstPostTerminal = noop/* default */.Z;
8054 this.cstPostNonTerminal = noop/* default */.Z;
8055 this.cstPostRule = noop/* default */.Z;
8056 }
8057 else {
8058 if (/full/i.test(this.nodeLocationTracking)) {
8059 if (this.recoveryEnabled) {
8060 this.setNodeLocationFromToken = setNodeLocationFull;
8061 this.setNodeLocationFromNode = setNodeLocationFull;
8062 this.cstPostRule = noop/* default */.Z;
8063 this.setInitialNodeLocation = this.setInitialNodeLocationFullRecovery;
8064 }
8065 else {
8066 this.setNodeLocationFromToken = noop/* default */.Z;
8067 this.setNodeLocationFromNode = noop/* default */.Z;
8068 this.cstPostRule = this.cstPostRuleFull;
8069 this.setInitialNodeLocation = this.setInitialNodeLocationFullRegular;
8070 }
8071 }
8072 else if (/onlyOffset/i.test(this.nodeLocationTracking)) {
8073 if (this.recoveryEnabled) {
8074 this.setNodeLocationFromToken = setNodeLocationOnlyOffset;
8075 this.setNodeLocationFromNode = setNodeLocationOnlyOffset;
8076 this.cstPostRule = noop/* default */.Z;
8077 this.setInitialNodeLocation =
8078 this.setInitialNodeLocationOnlyOffsetRecovery;
8079 }
8080 else {
8081 this.setNodeLocationFromToken = noop/* default */.Z;
8082 this.setNodeLocationFromNode = noop/* default */.Z;
8083 this.cstPostRule = this.cstPostRuleOnlyOffset;
8084 this.setInitialNodeLocation =
8085 this.setInitialNodeLocationOnlyOffsetRegular;
8086 }
8087 }
8088 else if (/none/i.test(this.nodeLocationTracking)) {
8089 this.setNodeLocationFromToken = noop/* default */.Z;
8090 this.setNodeLocationFromNode = noop/* default */.Z;
8091 this.cstPostRule = noop/* default */.Z;
8092 this.setInitialNodeLocation = noop/* default */.Z;
8093 }
8094 else {
8095 throw Error(`Invalid <nodeLocationTracking> config option: "${config.nodeLocationTracking}"`);
8096 }
8097 }
8098 }
8099 setInitialNodeLocationOnlyOffsetRecovery(cstNode) {
8100 cstNode.location = {
8101 startOffset: NaN,
8102 endOffset: NaN,
8103 };
8104 }
8105 setInitialNodeLocationOnlyOffsetRegular(cstNode) {
8106 cstNode.location = {
8107 // without error recovery the starting Location of a new CstNode is guaranteed
8108 // To be the next Token's startOffset (for valid inputs).
8109 // For invalid inputs there won't be any CSTOutput so this potential
8110 // inaccuracy does not matter
8111 startOffset: this.LA(1).startOffset,
8112 endOffset: NaN,
8113 };
8114 }
8115 setInitialNodeLocationFullRecovery(cstNode) {
8116 cstNode.location = {
8117 startOffset: NaN,
8118 startLine: NaN,
8119 startColumn: NaN,
8120 endOffset: NaN,
8121 endLine: NaN,
8122 endColumn: NaN,
8123 };
8124 }
8125 /**
8126 * @see setInitialNodeLocationOnlyOffsetRegular for explanation why this work
8127
8128 * @param cstNode
8129 */
8130 setInitialNodeLocationFullRegular(cstNode) {
8131 const nextToken = this.LA(1);
8132 cstNode.location = {
8133 startOffset: nextToken.startOffset,
8134 startLine: nextToken.startLine,
8135 startColumn: nextToken.startColumn,
8136 endOffset: NaN,
8137 endLine: NaN,
8138 endColumn: NaN,
8139 };
8140 }
8141 cstInvocationStateUpdate(fullRuleName) {
8142 const cstNode = {
8143 name: fullRuleName,
8144 children: Object.create(null),
8145 };
8146 this.setInitialNodeLocation(cstNode);
8147 this.CST_STACK.push(cstNode);
8148 }
8149 cstFinallyStateUpdate() {
8150 this.CST_STACK.pop();
8151 }
8152 cstPostRuleFull(ruleCstNode) {
8153 // casts to `required<CstNodeLocation>` are safe because `cstPostRuleFull` should only be invoked when full location is enabled
8154 const prevToken = this.LA(0);
8155 const loc = ruleCstNode.location;
8156 // If this condition is true it means we consumed at least one Token
8157 // In this CstNode.
8158 if (loc.startOffset <= prevToken.startOffset === true) {
8159 loc.endOffset = prevToken.endOffset;
8160 loc.endLine = prevToken.endLine;
8161 loc.endColumn = prevToken.endColumn;
8162 }
8163 // "empty" CstNode edge case
8164 else {
8165 loc.startOffset = NaN;
8166 loc.startLine = NaN;
8167 loc.startColumn = NaN;
8168 }
8169 }
8170 cstPostRuleOnlyOffset(ruleCstNode) {
8171 const prevToken = this.LA(0);
8172 // `location' is not null because `cstPostRuleOnlyOffset` will only be invoked when location tracking is enabled.
8173 const loc = ruleCstNode.location;
8174 // If this condition is true it means we consumed at least one Token
8175 // In this CstNode.
8176 if (loc.startOffset <= prevToken.startOffset === true) {
8177 loc.endOffset = prevToken.endOffset;
8178 }
8179 // "empty" CstNode edge case
8180 else {
8181 loc.startOffset = NaN;
8182 }
8183 }
8184 cstPostTerminal(key, consumedToken) {
8185 const rootCst = this.CST_STACK[this.CST_STACK.length - 1];
8186 addTerminalToCst(rootCst, consumedToken, key);
8187 // This is only used when **both** error recovery and CST Output are enabled.
8188 this.setNodeLocationFromToken(rootCst.location, consumedToken);
8189 }
8190 cstPostNonTerminal(ruleCstResult, ruleName) {
8191 const preCstNode = this.CST_STACK[this.CST_STACK.length - 1];
8192 addNoneTerminalToCst(preCstNode, ruleName, ruleCstResult);
8193 // This is only used when **both** error recovery and CST Output are enabled.
8194 this.setNodeLocationFromNode(preCstNode.location, ruleCstResult.location);
8195 }
8196 getBaseCstVisitorConstructor() {
8197 if ((0,isUndefined/* default */.Z)(this.baseCstVisitorConstructor)) {
8198 const newBaseCstVisitorConstructor = createBaseSemanticVisitorConstructor(this.className, (0,keys/* default */.Z)(this.gastProductionsCache));
8199 this.baseCstVisitorConstructor = newBaseCstVisitorConstructor;
8200 return newBaseCstVisitorConstructor;
8201 }
8202 return this.baseCstVisitorConstructor;
8203 }
8204 getBaseCstVisitorConstructorWithDefaults() {
8205 if ((0,isUndefined/* default */.Z)(this.baseCstVisitorWithDefaultsConstructor)) {
8206 const newConstructor = createBaseVisitorConstructorWithDefaults(this.className, (0,keys/* default */.Z)(this.gastProductionsCache), this.getBaseCstVisitorConstructor());
8207 this.baseCstVisitorWithDefaultsConstructor = newConstructor;
8208 return newConstructor;
8209 }
8210 return this.baseCstVisitorWithDefaultsConstructor;
8211 }
8212 getLastExplicitRuleShortName() {
8213 const ruleStack = this.RULE_STACK;
8214 return ruleStack[ruleStack.length - 1];
8215 }
8216 getPreviousExplicitRuleShortName() {
8217 const ruleStack = this.RULE_STACK;
8218 return ruleStack[ruleStack.length - 2];
8219 }
8220 getLastExplicitRuleOccurrenceIndex() {
8221 const occurrenceStack = this.RULE_OCCURRENCE_STACK;
8222 return occurrenceStack[occurrenceStack.length - 1];
8223 }
8224 }
8225 //# sourceMappingURL=tree_builder.js.map
8226 ;// CONCATENATED MODULE: ../node_modules/chevrotain/lib/src/parse/parser/traits/lexer_adapter.js
8227
8228 /**
8229 * Trait responsible abstracting over the interaction with Lexer output (Token vector).
8230 *
8231 * This could be generalized to support other kinds of lexers, e.g.
8232 * - Just in Time Lexing / Lexer-Less parsing.
8233 * - Streaming Lexer.
8234 */
8235 class LexerAdapter {
8236 initLexerAdapter() {
8237 this.tokVector = [];
8238 this.tokVectorLength = 0;
8239 this.currIdx = -1;
8240 }
8241 set input(newInput) {
8242 // @ts-ignore - `this parameter` not supported in setters/getters
8243 // - https://www.typescriptlang.org/docs/handbook/functions.html#this-parameters
8244 if (this.selfAnalysisDone !== true) {
8245 throw Error(`Missing <performSelfAnalysis> invocation at the end of the Parser's constructor.`);
8246 }
8247 // @ts-ignore - `this parameter` not supported in setters/getters
8248 // - https://www.typescriptlang.org/docs/handbook/functions.html#this-parameters
8249 this.reset();
8250 this.tokVector = newInput;
8251 this.tokVectorLength = newInput.length;
8252 }
8253 get input() {
8254 return this.tokVector;
8255 }
8256 // skips a token and returns the next token
8257 SKIP_TOKEN() {
8258 if (this.currIdx <= this.tokVector.length - 2) {
8259 this.consumeToken();
8260 return this.LA(1);
8261 }
8262 else {
8263 return END_OF_FILE;
8264 }
8265 }
8266 // Lexer (accessing Token vector) related methods which can be overridden to implement lazy lexers
8267 // or lexers dependent on parser context.
8268 LA(howMuch) {
8269 const soughtIdx = this.currIdx + howMuch;
8270 if (soughtIdx < 0 || this.tokVectorLength <= soughtIdx) {
8271 return END_OF_FILE;
8272 }
8273 else {
8274 return this.tokVector[soughtIdx];
8275 }
8276 }
8277 consumeToken() {
8278 this.currIdx++;
8279 }
8280 exportLexerState() {
8281 return this.currIdx;
8282 }
8283 importLexerState(newState) {
8284 this.currIdx = newState;
8285 }
8286 resetLexerState() {
8287 this.currIdx = -1;
8288 }
8289 moveToTerminatedState() {
8290 this.currIdx = this.tokVector.length - 1;
8291 }
8292 getLexerPosition() {
8293 return this.exportLexerState();
8294 }
8295 }
8296 //# sourceMappingURL=lexer_adapter.js.map
8297 ;// CONCATENATED MODULE: ../node_modules/chevrotain/lib/src/parse/parser/traits/recognizer_api.js
8298
8299
8300
8301
8302
8303
8304 /**
8305 * This trait is responsible for implementing the public API
8306 * for defining Chevrotain parsers, i.e:
8307 * - CONSUME
8308 * - RULE
8309 * - OPTION
8310 * - ...
8311 */
8312 class RecognizerApi {
8313 ACTION(impl) {
8314 return impl.call(this);
8315 }
8316 consume(idx, tokType, options) {
8317 return this.consumeInternal(tokType, idx, options);
8318 }
8319 subrule(idx, ruleToCall, options) {
8320 return this.subruleInternal(ruleToCall, idx, options);
8321 }
8322 option(idx, actionORMethodDef) {
8323 return this.optionInternal(actionORMethodDef, idx);
8324 }
8325 or(idx, altsOrOpts) {
8326 return this.orInternal(altsOrOpts, idx);
8327 }
8328 many(idx, actionORMethodDef) {
8329 return this.manyInternal(idx, actionORMethodDef);
8330 }
8331 atLeastOne(idx, actionORMethodDef) {
8332 return this.atLeastOneInternal(idx, actionORMethodDef);
8333 }
8334 CONSUME(tokType, options) {
8335 return this.consumeInternal(tokType, 0, options);
8336 }
8337 CONSUME1(tokType, options) {
8338 return this.consumeInternal(tokType, 1, options);
8339 }
8340 CONSUME2(tokType, options) {
8341 return this.consumeInternal(tokType, 2, options);
8342 }
8343 CONSUME3(tokType, options) {
8344 return this.consumeInternal(tokType, 3, options);
8345 }
8346 CONSUME4(tokType, options) {
8347 return this.consumeInternal(tokType, 4, options);
8348 }
8349 CONSUME5(tokType, options) {
8350 return this.consumeInternal(tokType, 5, options);
8351 }
8352 CONSUME6(tokType, options) {
8353 return this.consumeInternal(tokType, 6, options);
8354 }
8355 CONSUME7(tokType, options) {
8356 return this.consumeInternal(tokType, 7, options);
8357 }
8358 CONSUME8(tokType, options) {
8359 return this.consumeInternal(tokType, 8, options);
8360 }
8361 CONSUME9(tokType, options) {
8362 return this.consumeInternal(tokType, 9, options);
8363 }
8364 SUBRULE(ruleToCall, options) {
8365 return this.subruleInternal(ruleToCall, 0, options);
8366 }
8367 SUBRULE1(ruleToCall, options) {
8368 return this.subruleInternal(ruleToCall, 1, options);
8369 }
8370 SUBRULE2(ruleToCall, options) {
8371 return this.subruleInternal(ruleToCall, 2, options);
8372 }
8373 SUBRULE3(ruleToCall, options) {
8374 return this.subruleInternal(ruleToCall, 3, options);
8375 }
8376 SUBRULE4(ruleToCall, options) {
8377 return this.subruleInternal(ruleToCall, 4, options);
8378 }
8379 SUBRULE5(ruleToCall, options) {
8380 return this.subruleInternal(ruleToCall, 5, options);
8381 }
8382 SUBRULE6(ruleToCall, options) {
8383 return this.subruleInternal(ruleToCall, 6, options);
8384 }
8385 SUBRULE7(ruleToCall, options) {
8386 return this.subruleInternal(ruleToCall, 7, options);
8387 }
8388 SUBRULE8(ruleToCall, options) {
8389 return this.subruleInternal(ruleToCall, 8, options);
8390 }
8391 SUBRULE9(ruleToCall, options) {
8392 return this.subruleInternal(ruleToCall, 9, options);
8393 }
8394 OPTION(actionORMethodDef) {
8395 return this.optionInternal(actionORMethodDef, 0);
8396 }
8397 OPTION1(actionORMethodDef) {
8398 return this.optionInternal(actionORMethodDef, 1);
8399 }
8400 OPTION2(actionORMethodDef) {
8401 return this.optionInternal(actionORMethodDef, 2);
8402 }
8403 OPTION3(actionORMethodDef) {
8404 return this.optionInternal(actionORMethodDef, 3);
8405 }
8406 OPTION4(actionORMethodDef) {
8407 return this.optionInternal(actionORMethodDef, 4);
8408 }
8409 OPTION5(actionORMethodDef) {
8410 return this.optionInternal(actionORMethodDef, 5);
8411 }
8412 OPTION6(actionORMethodDef) {
8413 return this.optionInternal(actionORMethodDef, 6);
8414 }
8415 OPTION7(actionORMethodDef) {
8416 return this.optionInternal(actionORMethodDef, 7);
8417 }
8418 OPTION8(actionORMethodDef) {
8419 return this.optionInternal(actionORMethodDef, 8);
8420 }
8421 OPTION9(actionORMethodDef) {
8422 return this.optionInternal(actionORMethodDef, 9);
8423 }
8424 OR(altsOrOpts) {
8425 return this.orInternal(altsOrOpts, 0);
8426 }
8427 OR1(altsOrOpts) {
8428 return this.orInternal(altsOrOpts, 1);
8429 }
8430 OR2(altsOrOpts) {
8431 return this.orInternal(altsOrOpts, 2);
8432 }
8433 OR3(altsOrOpts) {
8434 return this.orInternal(altsOrOpts, 3);
8435 }
8436 OR4(altsOrOpts) {
8437 return this.orInternal(altsOrOpts, 4);
8438 }
8439 OR5(altsOrOpts) {
8440 return this.orInternal(altsOrOpts, 5);
8441 }
8442 OR6(altsOrOpts) {
8443 return this.orInternal(altsOrOpts, 6);
8444 }
8445 OR7(altsOrOpts) {
8446 return this.orInternal(altsOrOpts, 7);
8447 }
8448 OR8(altsOrOpts) {
8449 return this.orInternal(altsOrOpts, 8);
8450 }
8451 OR9(altsOrOpts) {
8452 return this.orInternal(altsOrOpts, 9);
8453 }
8454 MANY(actionORMethodDef) {
8455 this.manyInternal(0, actionORMethodDef);
8456 }
8457 MANY1(actionORMethodDef) {
8458 this.manyInternal(1, actionORMethodDef);
8459 }
8460 MANY2(actionORMethodDef) {
8461 this.manyInternal(2, actionORMethodDef);
8462 }
8463 MANY3(actionORMethodDef) {
8464 this.manyInternal(3, actionORMethodDef);
8465 }
8466 MANY4(actionORMethodDef) {
8467 this.manyInternal(4, actionORMethodDef);
8468 }
8469 MANY5(actionORMethodDef) {
8470 this.manyInternal(5, actionORMethodDef);
8471 }
8472 MANY6(actionORMethodDef) {
8473 this.manyInternal(6, actionORMethodDef);
8474 }
8475 MANY7(actionORMethodDef) {
8476 this.manyInternal(7, actionORMethodDef);
8477 }
8478 MANY8(actionORMethodDef) {
8479 this.manyInternal(8, actionORMethodDef);
8480 }
8481 MANY9(actionORMethodDef) {
8482 this.manyInternal(9, actionORMethodDef);
8483 }
8484 MANY_SEP(options) {
8485 this.manySepFirstInternal(0, options);
8486 }
8487 MANY_SEP1(options) {
8488 this.manySepFirstInternal(1, options);
8489 }
8490 MANY_SEP2(options) {
8491 this.manySepFirstInternal(2, options);
8492 }
8493 MANY_SEP3(options) {
8494 this.manySepFirstInternal(3, options);
8495 }
8496 MANY_SEP4(options) {
8497 this.manySepFirstInternal(4, options);
8498 }
8499 MANY_SEP5(options) {
8500 this.manySepFirstInternal(5, options);
8501 }
8502 MANY_SEP6(options) {
8503 this.manySepFirstInternal(6, options);
8504 }
8505 MANY_SEP7(options) {
8506 this.manySepFirstInternal(7, options);
8507 }
8508 MANY_SEP8(options) {
8509 this.manySepFirstInternal(8, options);
8510 }
8511 MANY_SEP9(options) {
8512 this.manySepFirstInternal(9, options);
8513 }
8514 AT_LEAST_ONE(actionORMethodDef) {
8515 this.atLeastOneInternal(0, actionORMethodDef);
8516 }
8517 AT_LEAST_ONE1(actionORMethodDef) {
8518 return this.atLeastOneInternal(1, actionORMethodDef);
8519 }
8520 AT_LEAST_ONE2(actionORMethodDef) {
8521 this.atLeastOneInternal(2, actionORMethodDef);
8522 }
8523 AT_LEAST_ONE3(actionORMethodDef) {
8524 this.atLeastOneInternal(3, actionORMethodDef);
8525 }
8526 AT_LEAST_ONE4(actionORMethodDef) {
8527 this.atLeastOneInternal(4, actionORMethodDef);
8528 }
8529 AT_LEAST_ONE5(actionORMethodDef) {
8530 this.atLeastOneInternal(5, actionORMethodDef);
8531 }
8532 AT_LEAST_ONE6(actionORMethodDef) {
8533 this.atLeastOneInternal(6, actionORMethodDef);
8534 }
8535 AT_LEAST_ONE7(actionORMethodDef) {
8536 this.atLeastOneInternal(7, actionORMethodDef);
8537 }
8538 AT_LEAST_ONE8(actionORMethodDef) {
8539 this.atLeastOneInternal(8, actionORMethodDef);
8540 }
8541 AT_LEAST_ONE9(actionORMethodDef) {
8542 this.atLeastOneInternal(9, actionORMethodDef);
8543 }
8544 AT_LEAST_ONE_SEP(options) {
8545 this.atLeastOneSepFirstInternal(0, options);
8546 }
8547 AT_LEAST_ONE_SEP1(options) {
8548 this.atLeastOneSepFirstInternal(1, options);
8549 }
8550 AT_LEAST_ONE_SEP2(options) {
8551 this.atLeastOneSepFirstInternal(2, options);
8552 }
8553 AT_LEAST_ONE_SEP3(options) {
8554 this.atLeastOneSepFirstInternal(3, options);
8555 }
8556 AT_LEAST_ONE_SEP4(options) {
8557 this.atLeastOneSepFirstInternal(4, options);
8558 }
8559 AT_LEAST_ONE_SEP5(options) {
8560 this.atLeastOneSepFirstInternal(5, options);
8561 }
8562 AT_LEAST_ONE_SEP6(options) {
8563 this.atLeastOneSepFirstInternal(6, options);
8564 }
8565 AT_LEAST_ONE_SEP7(options) {
8566 this.atLeastOneSepFirstInternal(7, options);
8567 }
8568 AT_LEAST_ONE_SEP8(options) {
8569 this.atLeastOneSepFirstInternal(8, options);
8570 }
8571 AT_LEAST_ONE_SEP9(options) {
8572 this.atLeastOneSepFirstInternal(9, options);
8573 }
8574 RULE(name, implementation, config = DEFAULT_RULE_CONFIG) {
8575 if (lodash_es_includes(this.definedRulesNames, name)) {
8576 const errMsg = defaultGrammarValidatorErrorProvider.buildDuplicateRuleNameError({
8577 topLevelRule: name,
8578 grammarName: this.className,
8579 });
8580 const error = {
8581 message: errMsg,
8582 type: ParserDefinitionErrorType.DUPLICATE_RULE_NAME,
8583 ruleName: name,
8584 };
8585 this.definitionErrors.push(error);
8586 }
8587 this.definedRulesNames.push(name);
8588 const ruleImplementation = this.defineRule(name, implementation, config);
8589 this[name] = ruleImplementation;
8590 return ruleImplementation;
8591 }
8592 OVERRIDE_RULE(name, impl, config = DEFAULT_RULE_CONFIG) {
8593 const ruleErrors = validateRuleIsOverridden(name, this.definedRulesNames, this.className);
8594 this.definitionErrors = this.definitionErrors.concat(ruleErrors);
8595 const ruleImplementation = this.defineRule(name, impl, config);
8596 this[name] = ruleImplementation;
8597 return ruleImplementation;
8598 }
8599 BACKTRACK(grammarRule, args) {
8600 return function () {
8601 // save org state
8602 this.isBackTrackingStack.push(1);
8603 const orgState = this.saveRecogState();
8604 try {
8605 grammarRule.apply(this, args);
8606 // if no exception was thrown we have succeed parsing the rule.
8607 return true;
8608 }
8609 catch (e) {
8610 if (isRecognitionException(e)) {
8611 return false;
8612 }
8613 else {
8614 throw e;
8615 }
8616 }
8617 finally {
8618 this.reloadRecogState(orgState);
8619 this.isBackTrackingStack.pop();
8620 }
8621 };
8622 }
8623 // GAST export APIs
8624 getGAstProductions() {
8625 return this.gastProductionsCache;
8626 }
8627 getSerializedGastProductions() {
8628 return serializeGrammar((0,values/* default */.Z)(this.gastProductionsCache));
8629 }
8630 }
8631 //# sourceMappingURL=recognizer_api.js.map
8632 // EXTERNAL MODULE: ../node_modules/lodash-es/isObject.js
8633 var isObject = __webpack_require__(60417);
8634 ;// CONCATENATED MODULE: ../node_modules/chevrotain/lib/src/parse/parser/traits/recognizer_engine.js
8635
8636
8637
8638
8639
8640
8641
8642
8643
8644 /**
8645 * This trait is responsible for the runtime parsing engine
8646 * Used by the official API (recognizer_api.ts)
8647 */
8648 class RecognizerEngine {
8649 initRecognizerEngine(tokenVocabulary, config) {
8650 this.className = this.constructor.name;
8651 // TODO: would using an ES6 Map or plain object be faster (CST building scenario)
8652 this.shortRuleNameToFull = {};
8653 this.fullRuleNameToShort = {};
8654 this.ruleShortNameIdx = 256;
8655 this.tokenMatcher = tokenStructuredMatcherNoCategories;
8656 this.subruleIdx = 0;
8657 this.definedRulesNames = [];
8658 this.tokensMap = {};
8659 this.isBackTrackingStack = [];
8660 this.RULE_STACK = [];
8661 this.RULE_OCCURRENCE_STACK = [];
8662 this.gastProductionsCache = {};
8663 if ((0,has/* default */.Z)(config, "serializedGrammar")) {
8664 throw Error("The Parser's configuration can no longer contain a <serializedGrammar> property.\n" +
8665 "\tSee: https://chevrotain.io/docs/changes/BREAKING_CHANGES.html#_6-0-0\n" +
8666 "\tFor Further details.");
8667 }
8668 if ((0,isArray/* default */.Z)(tokenVocabulary)) {
8669 // This only checks for Token vocabularies provided as arrays.
8670 // That is good enough because the main objective is to detect users of pre-V4.0 APIs
8671 // rather than all edge cases of empty Token vocabularies.
8672 if ((0,isEmpty/* default */.Z)(tokenVocabulary)) {
8673 throw Error("A Token Vocabulary cannot be empty.\n" +
8674 "\tNote that the first argument for the parser constructor\n" +
8675 "\tis no longer a Token vector (since v4.0).");
8676 }
8677 if (typeof tokenVocabulary[0].startOffset === "number") {
8678 throw Error("The Parser constructor no longer accepts a token vector as the first argument.\n" +
8679 "\tSee: https://chevrotain.io/docs/changes/BREAKING_CHANGES.html#_4-0-0\n" +
8680 "\tFor Further details.");
8681 }
8682 }
8683 if ((0,isArray/* default */.Z)(tokenVocabulary)) {
8684 this.tokensMap = (0,reduce/* default */.Z)(tokenVocabulary, (acc, tokType) => {
8685 acc[tokType.name] = tokType;
8686 return acc;
8687 }, {});
8688 }
8689 else if ((0,has/* default */.Z)(tokenVocabulary, "modes") &&
8690 lodash_es_every((0,flatten/* default */.Z)((0,values/* default */.Z)(tokenVocabulary.modes)), isTokenType)) {
8691 const allTokenTypes = (0,flatten/* default */.Z)((0,values/* default */.Z)(tokenVocabulary.modes));
8692 const uniqueTokens = lodash_es_uniq(allTokenTypes);
8693 this.tokensMap = (0,reduce/* default */.Z)(uniqueTokens, (acc, tokType) => {
8694 acc[tokType.name] = tokType;
8695 return acc;
8696 }, {});
8697 }
8698 else if ((0,isObject/* default */.Z)(tokenVocabulary)) {
8699 this.tokensMap = (0,lodash_es_clone/* default */.Z)(tokenVocabulary);
8700 }
8701 else {
8702 throw new Error("<tokensDictionary> argument must be An Array of Token constructors," +
8703 " A dictionary of Token constructors or an IMultiModeLexerDefinition");
8704 }
8705 // always add EOF to the tokenNames -> constructors map. it is useful to assure all the input has been
8706 // parsed with a clear error message ("expecting EOF but found ...")
8707 this.tokensMap["EOF"] = EOF;
8708 const allTokenTypes = (0,has/* default */.Z)(tokenVocabulary, "modes")
8709 ? (0,flatten/* default */.Z)((0,values/* default */.Z)(tokenVocabulary.modes))
8710 : (0,values/* default */.Z)(tokenVocabulary);
8711 const noTokenCategoriesUsed = lodash_es_every(allTokenTypes, (tokenConstructor) => (0,isEmpty/* default */.Z)(tokenConstructor.categoryMatches));
8712 this.tokenMatcher = noTokenCategoriesUsed
8713 ? tokenStructuredMatcherNoCategories
8714 : tokenStructuredMatcher;
8715 // Because ES2015+ syntax should be supported for creating Token classes
8716 // We cannot assume that the Token classes were created using the "extendToken" utilities
8717 // Therefore we must augment the Token classes both on Lexer initialization and on Parser initialization
8718 augmentTokenTypes((0,values/* default */.Z)(this.tokensMap));
8719 }
8720 defineRule(ruleName, impl, config) {
8721 if (this.selfAnalysisDone) {
8722 throw Error(`Grammar rule <${ruleName}> may not be defined after the 'performSelfAnalysis' method has been called'\n` +
8723 `Make sure that all grammar rule definitions are done before 'performSelfAnalysis' is called.`);
8724 }
8725 const resyncEnabled = (0,has/* default */.Z)(config, "resyncEnabled")
8726 ? config.resyncEnabled // assumes end user provides the correct config value/type
8727 : DEFAULT_RULE_CONFIG.resyncEnabled;
8728 const recoveryValueFunc = (0,has/* default */.Z)(config, "recoveryValueFunc")
8729 ? config.recoveryValueFunc // assumes end user provides the correct config value/type
8730 : DEFAULT_RULE_CONFIG.recoveryValueFunc;
8731 // performance optimization: Use small integers as keys for the longer human readable "full" rule names.
8732 // this greatly improves Map access time (as much as 8% for some performance benchmarks).
8733 const shortName = this.ruleShortNameIdx << (BITS_FOR_METHOD_TYPE + BITS_FOR_OCCURRENCE_IDX);
8734 this.ruleShortNameIdx++;
8735 this.shortRuleNameToFull[shortName] = ruleName;
8736 this.fullRuleNameToShort[ruleName] = shortName;
8737 let invokeRuleWithTry;
8738 // Micro optimization, only check the condition **once** on rule definition
8739 // instead of **every single** rule invocation.
8740 if (this.outputCst === true) {
8741 invokeRuleWithTry = function invokeRuleWithTry(...args) {
8742 try {
8743 this.ruleInvocationStateUpdate(shortName, ruleName, this.subruleIdx);
8744 impl.apply(this, args);
8745 const cst = this.CST_STACK[this.CST_STACK.length - 1];
8746 this.cstPostRule(cst);
8747 return cst;
8748 }
8749 catch (e) {
8750 return this.invokeRuleCatch(e, resyncEnabled, recoveryValueFunc);
8751 }
8752 finally {
8753 this.ruleFinallyStateUpdate();
8754 }
8755 };
8756 }
8757 else {
8758 invokeRuleWithTry = function invokeRuleWithTryCst(...args) {
8759 try {
8760 this.ruleInvocationStateUpdate(shortName, ruleName, this.subruleIdx);
8761 return impl.apply(this, args);
8762 }
8763 catch (e) {
8764 return this.invokeRuleCatch(e, resyncEnabled, recoveryValueFunc);
8765 }
8766 finally {
8767 this.ruleFinallyStateUpdate();
8768 }
8769 };
8770 }
8771 const wrappedGrammarRule = Object.assign(invokeRuleWithTry, { ruleName, originalGrammarAction: impl });
8772 return wrappedGrammarRule;
8773 }
8774 invokeRuleCatch(e, resyncEnabledConfig, recoveryValueFunc) {
8775 const isFirstInvokedRule = this.RULE_STACK.length === 1;
8776 // note the reSync is always enabled for the first rule invocation, because we must always be able to
8777 // reSync with EOF and just output some INVALID ParseTree
8778 // during backtracking reSync recovery is disabled, otherwise we can't be certain the backtracking
8779 // path is really the most valid one
8780 const reSyncEnabled = resyncEnabledConfig && !this.isBackTracking() && this.recoveryEnabled;
8781 if (isRecognitionException(e)) {
8782 const recogError = e;
8783 if (reSyncEnabled) {
8784 const reSyncTokType = this.findReSyncTokenType();
8785 if (this.isInCurrentRuleReSyncSet(reSyncTokType)) {
8786 recogError.resyncedTokens = this.reSyncTo(reSyncTokType);
8787 if (this.outputCst) {
8788 const partialCstResult = this.CST_STACK[this.CST_STACK.length - 1];
8789 partialCstResult.recoveredNode = true;
8790 return partialCstResult;
8791 }
8792 else {
8793 return recoveryValueFunc(e);
8794 }
8795 }
8796 else {
8797 if (this.outputCst) {
8798 const partialCstResult = this.CST_STACK[this.CST_STACK.length - 1];
8799 partialCstResult.recoveredNode = true;
8800 recogError.partialCstResult = partialCstResult;
8801 }
8802 // to be handled Further up the call stack
8803 throw recogError;
8804 }
8805 }
8806 else if (isFirstInvokedRule) {
8807 // otherwise a Redundant input error will be created as well and we cannot guarantee that this is indeed the case
8808 this.moveToTerminatedState();
8809 // the parser should never throw one of its own errors outside its flow.
8810 // even if error recovery is disabled
8811 return recoveryValueFunc(e);
8812 }
8813 else {
8814 // to be recovered Further up the call stack
8815 throw recogError;
8816 }
8817 }
8818 else {
8819 // some other Error type which we don't know how to handle (for example a built in JavaScript Error)
8820 throw e;
8821 }
8822 }
8823 // Implementation of parsing DSL
8824 optionInternal(actionORMethodDef, occurrence) {
8825 const key = this.getKeyForAutomaticLookahead(OPTION_IDX, occurrence);
8826 return this.optionInternalLogic(actionORMethodDef, occurrence, key);
8827 }
8828 optionInternalLogic(actionORMethodDef, occurrence, key) {
8829 let lookAheadFunc = this.getLaFuncFromCache(key);
8830 let action;
8831 if (typeof actionORMethodDef !== "function") {
8832 action = actionORMethodDef.DEF;
8833 const predicate = actionORMethodDef.GATE;
8834 // predicate present
8835 if (predicate !== undefined) {
8836 const orgLookaheadFunction = lookAheadFunc;
8837 lookAheadFunc = () => {
8838 return predicate.call(this) && orgLookaheadFunction.call(this);
8839 };
8840 }
8841 }
8842 else {
8843 action = actionORMethodDef;
8844 }
8845 if (lookAheadFunc.call(this) === true) {
8846 return action.call(this);
8847 }
8848 return undefined;
8849 }
8850 atLeastOneInternal(prodOccurrence, actionORMethodDef) {
8851 const laKey = this.getKeyForAutomaticLookahead(AT_LEAST_ONE_IDX, prodOccurrence);
8852 return this.atLeastOneInternalLogic(prodOccurrence, actionORMethodDef, laKey);
8853 }
8854 atLeastOneInternalLogic(prodOccurrence, actionORMethodDef, key) {
8855 let lookAheadFunc = this.getLaFuncFromCache(key);
8856 let action;
8857 if (typeof actionORMethodDef !== "function") {
8858 action = actionORMethodDef.DEF;
8859 const predicate = actionORMethodDef.GATE;
8860 // predicate present
8861 if (predicate !== undefined) {
8862 const orgLookaheadFunction = lookAheadFunc;
8863 lookAheadFunc = () => {
8864 return predicate.call(this) && orgLookaheadFunction.call(this);
8865 };
8866 }
8867 }
8868 else {
8869 action = actionORMethodDef;
8870 }
8871 if (lookAheadFunc.call(this) === true) {
8872 let notStuck = this.doSingleRepetition(action);
8873 while (lookAheadFunc.call(this) === true &&
8874 notStuck === true) {
8875 notStuck = this.doSingleRepetition(action);
8876 }
8877 }
8878 else {
8879 throw this.raiseEarlyExitException(prodOccurrence, PROD_TYPE.REPETITION_MANDATORY, actionORMethodDef.ERR_MSG);
8880 }
8881 // note that while it may seem that this can cause an error because by using a recursive call to
8882 // AT_LEAST_ONE we change the grammar to AT_LEAST_TWO, AT_LEAST_THREE ... , the possible recursive call
8883 // from the tryInRepetitionRecovery(...) will only happen IFF there really are TWO/THREE/.... items.
8884 // Performance optimization: "attemptInRepetitionRecovery" will be defined as NOOP unless recovery is enabled
8885 this.attemptInRepetitionRecovery(this.atLeastOneInternal, [prodOccurrence, actionORMethodDef], lookAheadFunc, AT_LEAST_ONE_IDX, prodOccurrence, NextTerminalAfterAtLeastOneWalker);
8886 }
8887 atLeastOneSepFirstInternal(prodOccurrence, options) {
8888 const laKey = this.getKeyForAutomaticLookahead(AT_LEAST_ONE_SEP_IDX, prodOccurrence);
8889 this.atLeastOneSepFirstInternalLogic(prodOccurrence, options, laKey);
8890 }
8891 atLeastOneSepFirstInternalLogic(prodOccurrence, options, key) {
8892 const action = options.DEF;
8893 const separator = options.SEP;
8894 const firstIterationLookaheadFunc = this.getLaFuncFromCache(key);
8895 // 1st iteration
8896 if (firstIterationLookaheadFunc.call(this) === true) {
8897 action.call(this);
8898 // TODO: Optimization can move this function construction into "attemptInRepetitionRecovery"
8899 // because it is only needed in error recovery scenarios.
8900 const separatorLookAheadFunc = () => {
8901 return this.tokenMatcher(this.LA(1), separator);
8902 };
8903 // 2nd..nth iterations
8904 while (this.tokenMatcher(this.LA(1), separator) === true) {
8905 // note that this CONSUME will never enter recovery because
8906 // the separatorLookAheadFunc checks that the separator really does exist.
8907 this.CONSUME(separator);
8908 // No need for checking infinite loop here due to consuming the separator.
8909 action.call(this);
8910 }
8911 // Performance optimization: "attemptInRepetitionRecovery" will be defined as NOOP unless recovery is enabled
8912 this.attemptInRepetitionRecovery(this.repetitionSepSecondInternal, [
8913 prodOccurrence,
8914 separator,
8915 separatorLookAheadFunc,
8916 action,
8917 NextTerminalAfterAtLeastOneSepWalker,
8918 ], separatorLookAheadFunc, AT_LEAST_ONE_SEP_IDX, prodOccurrence, NextTerminalAfterAtLeastOneSepWalker);
8919 }
8920 else {
8921 throw this.raiseEarlyExitException(prodOccurrence, PROD_TYPE.REPETITION_MANDATORY_WITH_SEPARATOR, options.ERR_MSG);
8922 }
8923 }
8924 manyInternal(prodOccurrence, actionORMethodDef) {
8925 const laKey = this.getKeyForAutomaticLookahead(MANY_IDX, prodOccurrence);
8926 return this.manyInternalLogic(prodOccurrence, actionORMethodDef, laKey);
8927 }
8928 manyInternalLogic(prodOccurrence, actionORMethodDef, key) {
8929 let lookaheadFunction = this.getLaFuncFromCache(key);
8930 let action;
8931 if (typeof actionORMethodDef !== "function") {
8932 action = actionORMethodDef.DEF;
8933 const predicate = actionORMethodDef.GATE;
8934 // predicate present
8935 if (predicate !== undefined) {
8936 const orgLookaheadFunction = lookaheadFunction;
8937 lookaheadFunction = () => {
8938 return predicate.call(this) && orgLookaheadFunction.call(this);
8939 };
8940 }
8941 }
8942 else {
8943 action = actionORMethodDef;
8944 }
8945 let notStuck = true;
8946 while (lookaheadFunction.call(this) === true && notStuck === true) {
8947 notStuck = this.doSingleRepetition(action);
8948 }
8949 // Performance optimization: "attemptInRepetitionRecovery" will be defined as NOOP unless recovery is enabled
8950 this.attemptInRepetitionRecovery(this.manyInternal, [prodOccurrence, actionORMethodDef], lookaheadFunction, MANY_IDX, prodOccurrence, NextTerminalAfterManyWalker,
8951 // The notStuck parameter is only relevant when "attemptInRepetitionRecovery"
8952 // is invoked from manyInternal, in the MANY_SEP case and AT_LEAST_ONE[_SEP]
8953 // An infinite loop cannot occur as:
8954 // - Either the lookahead is guaranteed to consume something (Single Token Separator)
8955 // - AT_LEAST_ONE by definition is guaranteed to consume something (or error out).
8956 notStuck);
8957 }
8958 manySepFirstInternal(prodOccurrence, options) {
8959 const laKey = this.getKeyForAutomaticLookahead(MANY_SEP_IDX, prodOccurrence);
8960 this.manySepFirstInternalLogic(prodOccurrence, options, laKey);
8961 }
8962 manySepFirstInternalLogic(prodOccurrence, options, key) {
8963 const action = options.DEF;
8964 const separator = options.SEP;
8965 const firstIterationLaFunc = this.getLaFuncFromCache(key);
8966 // 1st iteration
8967 if (firstIterationLaFunc.call(this) === true) {
8968 action.call(this);
8969 const separatorLookAheadFunc = () => {
8970 return this.tokenMatcher(this.LA(1), separator);
8971 };
8972 // 2nd..nth iterations
8973 while (this.tokenMatcher(this.LA(1), separator) === true) {
8974 // note that this CONSUME will never enter recovery because
8975 // the separatorLookAheadFunc checks that the separator really does exist.
8976 this.CONSUME(separator);
8977 // No need for checking infinite loop here due to consuming the separator.
8978 action.call(this);
8979 }
8980 // Performance optimization: "attemptInRepetitionRecovery" will be defined as NOOP unless recovery is enabled
8981 this.attemptInRepetitionRecovery(this.repetitionSepSecondInternal, [
8982 prodOccurrence,
8983 separator,
8984 separatorLookAheadFunc,
8985 action,
8986 NextTerminalAfterManySepWalker,
8987 ], separatorLookAheadFunc, MANY_SEP_IDX, prodOccurrence, NextTerminalAfterManySepWalker);
8988 }
8989 }
8990 repetitionSepSecondInternal(prodOccurrence, separator, separatorLookAheadFunc, action, nextTerminalAfterWalker) {
8991 while (separatorLookAheadFunc()) {
8992 // note that this CONSUME will never enter recovery because
8993 // the separatorLookAheadFunc checks that the separator really does exist.
8994 this.CONSUME(separator);
8995 action.call(this);
8996 }
8997 // we can only arrive to this function after an error
8998 // has occurred (hence the name 'second') so the following
8999 // IF will always be entered, its possible to remove it...
9000 // however it is kept to avoid confusion and be consistent.
9001 // Performance optimization: "attemptInRepetitionRecovery" will be defined as NOOP unless recovery is enabled
9002 /* istanbul ignore else */
9003 this.attemptInRepetitionRecovery(this.repetitionSepSecondInternal, [
9004 prodOccurrence,
9005 separator,
9006 separatorLookAheadFunc,
9007 action,
9008 nextTerminalAfterWalker,
9009 ], separatorLookAheadFunc, AT_LEAST_ONE_SEP_IDX, prodOccurrence, nextTerminalAfterWalker);
9010 }
9011 doSingleRepetition(action) {
9012 const beforeIteration = this.getLexerPosition();
9013 action.call(this);
9014 const afterIteration = this.getLexerPosition();
9015 // This boolean will indicate if this repetition progressed
9016 // or if we are "stuck" (potential infinite loop in the repetition).
9017 return afterIteration > beforeIteration;
9018 }
9019 orInternal(altsOrOpts, occurrence) {
9020 const laKey = this.getKeyForAutomaticLookahead(OR_IDX, occurrence);
9021 const alts = (0,isArray/* default */.Z)(altsOrOpts) ? altsOrOpts : altsOrOpts.DEF;
9022 const laFunc = this.getLaFuncFromCache(laKey);
9023 const altIdxToTake = laFunc.call(this, alts);
9024 if (altIdxToTake !== undefined) {
9025 const chosenAlternative = alts[altIdxToTake];
9026 return chosenAlternative.ALT.call(this);
9027 }
9028 this.raiseNoAltException(occurrence, altsOrOpts.ERR_MSG);
9029 }
9030 ruleFinallyStateUpdate() {
9031 this.RULE_STACK.pop();
9032 this.RULE_OCCURRENCE_STACK.pop();
9033 // NOOP when cst is disabled
9034 this.cstFinallyStateUpdate();
9035 if (this.RULE_STACK.length === 0 && this.isAtEndOfInput() === false) {
9036 const firstRedundantTok = this.LA(1);
9037 const errMsg = this.errorMessageProvider.buildNotAllInputParsedMessage({
9038 firstRedundant: firstRedundantTok,
9039 ruleName: this.getCurrRuleFullName(),
9040 });
9041 this.SAVE_ERROR(new NotAllInputParsedException(errMsg, firstRedundantTok));
9042 }
9043 }
9044 subruleInternal(ruleToCall, idx, options) {
9045 let ruleResult;
9046 try {
9047 const args = options !== undefined ? options.ARGS : undefined;
9048 this.subruleIdx = idx;
9049 ruleResult = ruleToCall.apply(this, args);
9050 this.cstPostNonTerminal(ruleResult, options !== undefined && options.LABEL !== undefined
9051 ? options.LABEL
9052 : ruleToCall.ruleName);
9053 return ruleResult;
9054 }
9055 catch (e) {
9056 throw this.subruleInternalError(e, options, ruleToCall.ruleName);
9057 }
9058 }
9059 subruleInternalError(e, options, ruleName) {
9060 if (isRecognitionException(e) && e.partialCstResult !== undefined) {
9061 this.cstPostNonTerminal(e.partialCstResult, options !== undefined && options.LABEL !== undefined
9062 ? options.LABEL
9063 : ruleName);
9064 delete e.partialCstResult;
9065 }
9066 throw e;
9067 }
9068 consumeInternal(tokType, idx, options) {
9069 let consumedToken;
9070 try {
9071 const nextToken = this.LA(1);
9072 if (this.tokenMatcher(nextToken, tokType) === true) {
9073 this.consumeToken();
9074 consumedToken = nextToken;
9075 }
9076 else {
9077 this.consumeInternalError(tokType, nextToken, options);
9078 }
9079 }
9080 catch (eFromConsumption) {
9081 consumedToken = this.consumeInternalRecovery(tokType, idx, eFromConsumption);
9082 }
9083 this.cstPostTerminal(options !== undefined && options.LABEL !== undefined
9084 ? options.LABEL
9085 : tokType.name, consumedToken);
9086 return consumedToken;
9087 }
9088 consumeInternalError(tokType, nextToken, options) {
9089 let msg;
9090 const previousToken = this.LA(0);
9091 if (options !== undefined && options.ERR_MSG) {
9092 msg = options.ERR_MSG;
9093 }
9094 else {
9095 msg = this.errorMessageProvider.buildMismatchTokenMessage({
9096 expected: tokType,
9097 actual: nextToken,
9098 previous: previousToken,
9099 ruleName: this.getCurrRuleFullName(),
9100 });
9101 }
9102 throw this.SAVE_ERROR(new MismatchedTokenException(msg, nextToken, previousToken));
9103 }
9104 consumeInternalRecovery(tokType, idx, eFromConsumption) {
9105 // no recovery allowed during backtracking, otherwise backtracking may recover invalid syntax and accept it
9106 // but the original syntax could have been parsed successfully without any backtracking + recovery
9107 if (this.recoveryEnabled &&
9108 // TODO: more robust checking of the exception type. Perhaps Typescript extending expressions?
9109 eFromConsumption.name === "MismatchedTokenException" &&
9110 !this.isBackTracking()) {
9111 const follows = this.getFollowsForInRuleRecovery(tokType, idx);
9112 try {
9113 return this.tryInRuleRecovery(tokType, follows);
9114 }
9115 catch (eFromInRuleRecovery) {
9116 if (eFromInRuleRecovery.name === IN_RULE_RECOVERY_EXCEPTION) {
9117 // failed in RuleRecovery.
9118 // throw the original error in order to trigger reSync error recovery
9119 throw eFromConsumption;
9120 }
9121 else {
9122 throw eFromInRuleRecovery;
9123 }
9124 }
9125 }
9126 else {
9127 throw eFromConsumption;
9128 }
9129 }
9130 saveRecogState() {
9131 // errors is a getter which will clone the errors array
9132 const savedErrors = this.errors;
9133 const savedRuleStack = (0,lodash_es_clone/* default */.Z)(this.RULE_STACK);
9134 return {
9135 errors: savedErrors,
9136 lexerState: this.exportLexerState(),
9137 RULE_STACK: savedRuleStack,
9138 CST_STACK: this.CST_STACK,
9139 };
9140 }
9141 reloadRecogState(newState) {
9142 this.errors = newState.errors;
9143 this.importLexerState(newState.lexerState);
9144 this.RULE_STACK = newState.RULE_STACK;
9145 }
9146 ruleInvocationStateUpdate(shortName, fullName, idxInCallingRule) {
9147 this.RULE_OCCURRENCE_STACK.push(idxInCallingRule);
9148 this.RULE_STACK.push(shortName);
9149 // NOOP when cst is disabled
9150 this.cstInvocationStateUpdate(fullName);
9151 }
9152 isBackTracking() {
9153 return this.isBackTrackingStack.length !== 0;
9154 }
9155 getCurrRuleFullName() {
9156 const shortName = this.getLastExplicitRuleShortName();
9157 return this.shortRuleNameToFull[shortName];
9158 }
9159 shortRuleNameToFullName(shortName) {
9160 return this.shortRuleNameToFull[shortName];
9161 }
9162 isAtEndOfInput() {
9163 return this.tokenMatcher(this.LA(1), EOF);
9164 }
9165 reset() {
9166 this.resetLexerState();
9167 this.subruleIdx = 0;
9168 this.isBackTrackingStack = [];
9169 this.errors = [];
9170 this.RULE_STACK = [];
9171 // TODO: extract a specific reset for TreeBuilder trait
9172 this.CST_STACK = [];
9173 this.RULE_OCCURRENCE_STACK = [];
9174 }
9175 }
9176 //# sourceMappingURL=recognizer_engine.js.map
9177 ;// CONCATENATED MODULE: ../node_modules/chevrotain/lib/src/parse/parser/traits/error_handler.js
9178
9179
9180
9181
9182 /**
9183 * Trait responsible for runtime parsing errors.
9184 */
9185 class ErrorHandler {
9186 initErrorHandler(config) {
9187 this._errors = [];
9188 this.errorMessageProvider = (0,has/* default */.Z)(config, "errorMessageProvider")
9189 ? config.errorMessageProvider // assumes end user provides the correct config value/type
9190 : DEFAULT_PARSER_CONFIG.errorMessageProvider;
9191 }
9192 SAVE_ERROR(error) {
9193 if (isRecognitionException(error)) {
9194 error.context = {
9195 ruleStack: this.getHumanReadableRuleStack(),
9196 ruleOccurrenceStack: (0,lodash_es_clone/* default */.Z)(this.RULE_OCCURRENCE_STACK),
9197 };
9198 this._errors.push(error);
9199 return error;
9200 }
9201 else {
9202 throw Error("Trying to save an Error which is not a RecognitionException");
9203 }
9204 }
9205 get errors() {
9206 return (0,lodash_es_clone/* default */.Z)(this._errors);
9207 }
9208 set errors(newErrors) {
9209 this._errors = newErrors;
9210 }
9211 // TODO: consider caching the error message computed information
9212 raiseEarlyExitException(occurrence, prodType, userDefinedErrMsg) {
9213 const ruleName = this.getCurrRuleFullName();
9214 const ruleGrammar = this.getGAstProductions()[ruleName];
9215 const lookAheadPathsPerAlternative = getLookaheadPathsForOptionalProd(occurrence, ruleGrammar, prodType, this.maxLookahead);
9216 const insideProdPaths = lookAheadPathsPerAlternative[0];
9217 const actualTokens = [];
9218 for (let i = 1; i <= this.maxLookahead; i++) {
9219 actualTokens.push(this.LA(i));
9220 }
9221 const msg = this.errorMessageProvider.buildEarlyExitMessage({
9222 expectedIterationPaths: insideProdPaths,
9223 actual: actualTokens,
9224 previous: this.LA(0),
9225 customUserDescription: userDefinedErrMsg,
9226 ruleName: ruleName,
9227 });
9228 throw this.SAVE_ERROR(new EarlyExitException(msg, this.LA(1), this.LA(0)));
9229 }
9230 // TODO: consider caching the error message computed information
9231 raiseNoAltException(occurrence, errMsgTypes) {
9232 const ruleName = this.getCurrRuleFullName();
9233 const ruleGrammar = this.getGAstProductions()[ruleName];
9234 // TODO: getLookaheadPathsForOr can be slow for large enough maxLookahead and certain grammars, consider caching ?
9235 const lookAheadPathsPerAlternative = getLookaheadPathsForOr(occurrence, ruleGrammar, this.maxLookahead);
9236 const actualTokens = [];
9237 for (let i = 1; i <= this.maxLookahead; i++) {
9238 actualTokens.push(this.LA(i));
9239 }
9240 const previousToken = this.LA(0);
9241 const errMsg = this.errorMessageProvider.buildNoViableAltMessage({
9242 expectedPathsPerAlt: lookAheadPathsPerAlternative,
9243 actual: actualTokens,
9244 previous: previousToken,
9245 customUserDescription: errMsgTypes,
9246 ruleName: this.getCurrRuleFullName(),
9247 });
9248 throw this.SAVE_ERROR(new NoViableAltException(errMsg, this.LA(1), previousToken));
9249 }
9250 }
9251 //# sourceMappingURL=error_handler.js.map
9252 ;// CONCATENATED MODULE: ../node_modules/chevrotain/lib/src/parse/parser/traits/context_assist.js
9253
9254
9255 class ContentAssist {
9256 initContentAssist() { }
9257 computeContentAssist(startRuleName, precedingInput) {
9258 const startRuleGast = this.gastProductionsCache[startRuleName];
9259 if ((0,isUndefined/* default */.Z)(startRuleGast)) {
9260 throw Error(`Rule ->${startRuleName}<- does not exist in this grammar.`);
9261 }
9262 return nextPossibleTokensAfter([startRuleGast], precedingInput, this.tokenMatcher, this.maxLookahead);
9263 }
9264 // TODO: should this be a member method or a utility? it does not have any state or usage of 'this'...
9265 // TODO: should this be more explicitly part of the public API?
9266 getNextPossibleTokenTypes(grammarPath) {
9267 const topRuleName = lodash_es_head(grammarPath.ruleStack);
9268 const gastProductions = this.getGAstProductions();
9269 const topProduction = gastProductions[topRuleName];
9270 const nextPossibleTokenTypes = new NextAfterTokenWalker(topProduction, grammarPath).startWalking();
9271 return nextPossibleTokenTypes;
9272 }
9273 }
9274 //# sourceMappingURL=context_assist.js.map
9275 ;// CONCATENATED MODULE: ../node_modules/chevrotain/lib/src/parse/parser/traits/gast_recorder.js
9276
9277
9278
9279
9280
9281
9282
9283 const RECORDING_NULL_OBJECT = {
9284 description: "This Object indicates the Parser is during Recording Phase",
9285 };
9286 Object.freeze(RECORDING_NULL_OBJECT);
9287 const HANDLE_SEPARATOR = true;
9288 const MAX_METHOD_IDX = Math.pow(2, BITS_FOR_OCCURRENCE_IDX) - 1;
9289 const RFT = createToken({ name: "RECORDING_PHASE_TOKEN", pattern: Lexer.NA });
9290 augmentTokenTypes([RFT]);
9291 const RECORDING_PHASE_TOKEN = createTokenInstance(RFT, "This IToken indicates the Parser is in Recording Phase\n\t" +
9292 "" +
9293 "See: https://chevrotain.io/docs/guide/internals.html#grammar-recording for details",
9294 // Using "-1" instead of NaN (as in EOF) because an actual number is less likely to
9295 // cause errors if the output of LA or CONSUME would be (incorrectly) used during the recording phase.
9296 -1, -1, -1, -1, -1, -1);
9297 Object.freeze(RECORDING_PHASE_TOKEN);
9298 const RECORDING_PHASE_CSTNODE = {
9299 name: "This CSTNode indicates the Parser is in Recording Phase\n\t" +
9300 "See: https://chevrotain.io/docs/guide/internals.html#grammar-recording for details",
9301 children: {},
9302 };
9303 /**
9304 * This trait handles the creation of the GAST structure for Chevrotain Grammars
9305 */
9306 class GastRecorder {
9307 initGastRecorder(config) {
9308 this.recordingProdStack = [];
9309 this.RECORDING_PHASE = false;
9310 }
9311 enableRecording() {
9312 this.RECORDING_PHASE = true;
9313 this.TRACE_INIT("Enable Recording", () => {
9314 /**
9315 * Warning Dark Voodoo Magic upcoming!
9316 * We are "replacing" the public parsing DSL methods API
9317 * With **new** alternative implementations on the Parser **instance**
9318 *
9319 * So far this is the only way I've found to avoid performance regressions during parsing time.
9320 * - Approx 30% performance regression was measured on Chrome 75 Canary when attempting to replace the "internal"
9321 * implementations directly instead.
9322 */
9323 for (let i = 0; i < 10; i++) {
9324 const idx = i > 0 ? i : "";
9325 this[`CONSUME${idx}`] = function (arg1, arg2) {
9326 return this.consumeInternalRecord(arg1, i, arg2);
9327 };
9328 this[`SUBRULE${idx}`] = function (arg1, arg2) {
9329 return this.subruleInternalRecord(arg1, i, arg2);
9330 };
9331 this[`OPTION${idx}`] = function (arg1) {
9332 return this.optionInternalRecord(arg1, i);
9333 };
9334 this[`OR${idx}`] = function (arg1) {
9335 return this.orInternalRecord(arg1, i);
9336 };
9337 this[`MANY${idx}`] = function (arg1) {
9338 this.manyInternalRecord(i, arg1);
9339 };
9340 this[`MANY_SEP${idx}`] = function (arg1) {
9341 this.manySepFirstInternalRecord(i, arg1);
9342 };
9343 this[`AT_LEAST_ONE${idx}`] = function (arg1) {
9344 this.atLeastOneInternalRecord(i, arg1);
9345 };
9346 this[`AT_LEAST_ONE_SEP${idx}`] = function (arg1) {
9347 this.atLeastOneSepFirstInternalRecord(i, arg1);
9348 };
9349 }
9350 // DSL methods with the idx(suffix) as an argument
9351 this[`consume`] = function (idx, arg1, arg2) {
9352 return this.consumeInternalRecord(arg1, idx, arg2);
9353 };
9354 this[`subrule`] = function (idx, arg1, arg2) {
9355 return this.subruleInternalRecord(arg1, idx, arg2);
9356 };
9357 this[`option`] = function (idx, arg1) {
9358 return this.optionInternalRecord(arg1, idx);
9359 };
9360 this[`or`] = function (idx, arg1) {
9361 return this.orInternalRecord(arg1, idx);
9362 };
9363 this[`many`] = function (idx, arg1) {
9364 this.manyInternalRecord(idx, arg1);
9365 };
9366 this[`atLeastOne`] = function (idx, arg1) {
9367 this.atLeastOneInternalRecord(idx, arg1);
9368 };
9369 this.ACTION = this.ACTION_RECORD;
9370 this.BACKTRACK = this.BACKTRACK_RECORD;
9371 this.LA = this.LA_RECORD;
9372 });
9373 }
9374 disableRecording() {
9375 this.RECORDING_PHASE = false;
9376 // By deleting these **instance** properties, any future invocation
9377 // will be deferred to the original methods on the **prototype** object
9378 // This seems to get rid of any incorrect optimizations that V8 may
9379 // do during the recording phase.
9380 this.TRACE_INIT("Deleting Recording methods", () => {
9381 const that = this;
9382 for (let i = 0; i < 10; i++) {
9383 const idx = i > 0 ? i : "";
9384 delete that[`CONSUME${idx}`];
9385 delete that[`SUBRULE${idx}`];
9386 delete that[`OPTION${idx}`];
9387 delete that[`OR${idx}`];
9388 delete that[`MANY${idx}`];
9389 delete that[`MANY_SEP${idx}`];
9390 delete that[`AT_LEAST_ONE${idx}`];
9391 delete that[`AT_LEAST_ONE_SEP${idx}`];
9392 }
9393 delete that[`consume`];
9394 delete that[`subrule`];
9395 delete that[`option`];
9396 delete that[`or`];
9397 delete that[`many`];
9398 delete that[`atLeastOne`];
9399 delete that.ACTION;
9400 delete that.BACKTRACK;
9401 delete that.LA;
9402 });
9403 }
9404 // Parser methods are called inside an ACTION?
9405 // Maybe try/catch/finally on ACTIONS while disabling the recorders state changes?
9406 // @ts-expect-error -- noop place holder
9407 ACTION_RECORD(impl) {
9408 // NO-OP during recording
9409 }
9410 // Executing backtracking logic will break our recording logic assumptions
9411 BACKTRACK_RECORD(grammarRule, args) {
9412 return () => true;
9413 }
9414 // LA is part of the official API and may be used for custom lookahead logic
9415 // by end users who may forget to wrap it in ACTION or inside a GATE
9416 LA_RECORD(howMuch) {
9417 // We cannot use the RECORD_PHASE_TOKEN here because someone may depend
9418 // On LA return EOF at the end of the input so an infinite loop may occur.
9419 return END_OF_FILE;
9420 }
9421 topLevelRuleRecord(name, def) {
9422 try {
9423 const newTopLevelRule = new Rule({ definition: [], name: name });
9424 newTopLevelRule.name = name;
9425 this.recordingProdStack.push(newTopLevelRule);
9426 def.call(this);
9427 this.recordingProdStack.pop();
9428 return newTopLevelRule;
9429 }
9430 catch (originalError) {
9431 if (originalError.KNOWN_RECORDER_ERROR !== true) {
9432 try {
9433 originalError.message =
9434 originalError.message +
9435 '\n\t This error was thrown during the "grammar recording phase" For more info see:\n\t' +
9436 "https://chevrotain.io/docs/guide/internals.html#grammar-recording";
9437 }
9438 catch (mutabilityError) {
9439 // We may not be able to modify the original error object
9440 throw originalError;
9441 }
9442 }
9443 throw originalError;
9444 }
9445 }
9446 // Implementation of parsing DSL
9447 optionInternalRecord(actionORMethodDef, occurrence) {
9448 return recordProd.call(this, Option, actionORMethodDef, occurrence);
9449 }
9450 atLeastOneInternalRecord(occurrence, actionORMethodDef) {
9451 recordProd.call(this, RepetitionMandatory, actionORMethodDef, occurrence);
9452 }
9453 atLeastOneSepFirstInternalRecord(occurrence, options) {
9454 recordProd.call(this, RepetitionMandatoryWithSeparator, options, occurrence, HANDLE_SEPARATOR);
9455 }
9456 manyInternalRecord(occurrence, actionORMethodDef) {
9457 recordProd.call(this, Repetition, actionORMethodDef, occurrence);
9458 }
9459 manySepFirstInternalRecord(occurrence, options) {
9460 recordProd.call(this, RepetitionWithSeparator, options, occurrence, HANDLE_SEPARATOR);
9461 }
9462 orInternalRecord(altsOrOpts, occurrence) {
9463 return recordOrProd.call(this, altsOrOpts, occurrence);
9464 }
9465 subruleInternalRecord(ruleToCall, occurrence, options) {
9466 assertMethodIdxIsValid(occurrence);
9467 if (!ruleToCall || (0,has/* default */.Z)(ruleToCall, "ruleName") === false) {
9468 const error = new Error(`<SUBRULE${getIdxSuffix(occurrence)}> argument is invalid` +
9469 ` expecting a Parser method reference but got: <${JSON.stringify(ruleToCall)}>` +
9470 `\n inside top level rule: <${this.recordingProdStack[0].name}>`);
9471 error.KNOWN_RECORDER_ERROR = true;
9472 throw error;
9473 }
9474 const prevProd = (0,last/* default */.Z)(this.recordingProdStack);
9475 const ruleName = ruleToCall.ruleName;
9476 const newNoneTerminal = new NonTerminal({
9477 idx: occurrence,
9478 nonTerminalName: ruleName,
9479 label: options === null || options === void 0 ? void 0 : options.LABEL,
9480 // The resolving of the `referencedRule` property will be done once all the Rule's GASTs have been created
9481 referencedRule: undefined,
9482 });
9483 prevProd.definition.push(newNoneTerminal);
9484 return this.outputCst
9485 ? RECORDING_PHASE_CSTNODE
9486 : RECORDING_NULL_OBJECT;
9487 }
9488 consumeInternalRecord(tokType, occurrence, options) {
9489 assertMethodIdxIsValid(occurrence);
9490 if (!hasShortKeyProperty(tokType)) {
9491 const error = new Error(`<CONSUME${getIdxSuffix(occurrence)}> argument is invalid` +
9492 ` expecting a TokenType reference but got: <${JSON.stringify(tokType)}>` +
9493 `\n inside top level rule: <${this.recordingProdStack[0].name}>`);
9494 error.KNOWN_RECORDER_ERROR = true;
9495 throw error;
9496 }
9497 const prevProd = (0,last/* default */.Z)(this.recordingProdStack);
9498 const newNoneTerminal = new Terminal({
9499 idx: occurrence,
9500 terminalType: tokType,
9501 label: options === null || options === void 0 ? void 0 : options.LABEL,
9502 });
9503 prevProd.definition.push(newNoneTerminal);
9504 return RECORDING_PHASE_TOKEN;
9505 }
9506 }
9507 function recordProd(prodConstructor, mainProdArg, occurrence, handleSep = false) {
9508 assertMethodIdxIsValid(occurrence);
9509 const prevProd = (0,last/* default */.Z)(this.recordingProdStack);
9510 const grammarAction = (0,isFunction/* default */.Z)(mainProdArg) ? mainProdArg : mainProdArg.DEF;
9511 const newProd = new prodConstructor({ definition: [], idx: occurrence });
9512 if (handleSep) {
9513 newProd.separator = mainProdArg.SEP;
9514 }
9515 if ((0,has/* default */.Z)(mainProdArg, "MAX_LOOKAHEAD")) {
9516 newProd.maxLookahead = mainProdArg.MAX_LOOKAHEAD;
9517 }
9518 this.recordingProdStack.push(newProd);
9519 grammarAction.call(this);
9520 prevProd.definition.push(newProd);
9521 this.recordingProdStack.pop();
9522 return RECORDING_NULL_OBJECT;
9523 }
9524 function recordOrProd(mainProdArg, occurrence) {
9525 assertMethodIdxIsValid(occurrence);
9526 const prevProd = (0,last/* default */.Z)(this.recordingProdStack);
9527 // Only an array of alternatives
9528 const hasOptions = (0,isArray/* default */.Z)(mainProdArg) === false;
9529 const alts = hasOptions === false ? mainProdArg : mainProdArg.DEF;
9530 const newOrProd = new Alternation({
9531 definition: [],
9532 idx: occurrence,
9533 ignoreAmbiguities: hasOptions && mainProdArg.IGNORE_AMBIGUITIES === true,
9534 });
9535 if ((0,has/* default */.Z)(mainProdArg, "MAX_LOOKAHEAD")) {
9536 newOrProd.maxLookahead = mainProdArg.MAX_LOOKAHEAD;
9537 }
9538 const hasPredicates = lodash_es_some(alts, (currAlt) => (0,isFunction/* default */.Z)(currAlt.GATE));
9539 newOrProd.hasPredicates = hasPredicates;
9540 prevProd.definition.push(newOrProd);
9541 (0,forEach/* default */.Z)(alts, (currAlt) => {
9542 const currAltFlat = new Alternative({ definition: [] });
9543 newOrProd.definition.push(currAltFlat);
9544 if ((0,has/* default */.Z)(currAlt, "IGNORE_AMBIGUITIES")) {
9545 currAltFlat.ignoreAmbiguities = currAlt.IGNORE_AMBIGUITIES; // assumes end user provides the correct config value/type
9546 }
9547 // **implicit** ignoreAmbiguities due to usage of gate
9548 else if ((0,has/* default */.Z)(currAlt, "GATE")) {
9549 currAltFlat.ignoreAmbiguities = true;
9550 }
9551 this.recordingProdStack.push(currAltFlat);
9552 currAlt.ALT.call(this);
9553 this.recordingProdStack.pop();
9554 });
9555 return RECORDING_NULL_OBJECT;
9556 }
9557 function getIdxSuffix(idx) {
9558 return idx === 0 ? "" : `${idx}`;
9559 }
9560 function assertMethodIdxIsValid(idx) {
9561 if (idx < 0 || idx > MAX_METHOD_IDX) {
9562 const error = new Error(
9563 // The stack trace will contain all the needed details
9564 `Invalid DSL Method idx value: <${idx}>\n\t` +
9565 `Idx value must be a none negative value smaller than ${MAX_METHOD_IDX + 1}`);
9566 error.KNOWN_RECORDER_ERROR = true;
9567 throw error;
9568 }
9569 }
9570 //# sourceMappingURL=gast_recorder.js.map
9571 ;// CONCATENATED MODULE: ../node_modules/chevrotain/lib/src/parse/parser/traits/perf_tracer.js
9572
9573
9574
9575 /**
9576 * Trait responsible for runtime parsing errors.
9577 */
9578 class PerformanceTracer {
9579 initPerformanceTracer(config) {
9580 if ((0,has/* default */.Z)(config, "traceInitPerf")) {
9581 const userTraceInitPerf = config.traceInitPerf;
9582 const traceIsNumber = typeof userTraceInitPerf === "number";
9583 this.traceInitMaxIdent = traceIsNumber
9584 ? userTraceInitPerf
9585 : Infinity;
9586 this.traceInitPerf = traceIsNumber
9587 ? userTraceInitPerf > 0
9588 : userTraceInitPerf; // assumes end user provides the correct config value/type
9589 }
9590 else {
9591 this.traceInitMaxIdent = 0;
9592 this.traceInitPerf = DEFAULT_PARSER_CONFIG.traceInitPerf;
9593 }
9594 this.traceInitIndent = -1;
9595 }
9596 TRACE_INIT(phaseDesc, phaseImpl) {
9597 // No need to optimize this using NOOP pattern because
9598 // It is not called in a hot spot...
9599 if (this.traceInitPerf === true) {
9600 this.traceInitIndent++;
9601 const indent = new Array(this.traceInitIndent + 1).join("\t");
9602 if (this.traceInitIndent < this.traceInitMaxIdent) {
9603 console.log(`${indent}--> <${phaseDesc}>`);
9604 }
9605 const { time, value } = timer(phaseImpl);
9606 /* istanbul ignore next - Difficult to reproduce specific performance behavior (>10ms) in tests */
9607 const traceMethod = time > 10 ? console.warn : console.log;
9608 if (this.traceInitIndent < this.traceInitMaxIdent) {
9609 traceMethod(`${indent}<-- <${phaseDesc}> time: ${time}ms`);
9610 }
9611 this.traceInitIndent--;
9612 return value;
9613 }
9614 else {
9615 return phaseImpl();
9616 }
9617 }
9618 }
9619 //# sourceMappingURL=perf_tracer.js.map
9620 ;// CONCATENATED MODULE: ../node_modules/chevrotain/lib/src/parse/parser/utils/apply_mixins.js
9621 function applyMixins(derivedCtor, baseCtors) {
9622 baseCtors.forEach((baseCtor) => {
9623 const baseProto = baseCtor.prototype;
9624 Object.getOwnPropertyNames(baseProto).forEach((propName) => {
9625 if (propName === "constructor") {
9626 return;
9627 }
9628 const basePropDescriptor = Object.getOwnPropertyDescriptor(baseProto, propName);
9629 // Handle Accessors
9630 if (basePropDescriptor &&
9631 (basePropDescriptor.get || basePropDescriptor.set)) {
9632 Object.defineProperty(derivedCtor.prototype, propName, basePropDescriptor);
9633 }
9634 else {
9635 derivedCtor.prototype[propName] = baseCtor.prototype[propName];
9636 }
9637 });
9638 });
9639 }
9640 //# sourceMappingURL=apply_mixins.js.map
9641 ;// CONCATENATED MODULE: ../node_modules/chevrotain/lib/src/parse/parser/parser.js
9642
9643
9644
9645
9646
9647
9648
9649
9650
9651
9652
9653
9654
9655
9656
9657
9658
9659
9660 const END_OF_FILE = createTokenInstance(EOF, "", NaN, NaN, NaN, NaN, NaN, NaN);
9661 Object.freeze(END_OF_FILE);
9662 const DEFAULT_PARSER_CONFIG = Object.freeze({
9663 recoveryEnabled: false,
9664 maxLookahead: 3,
9665 dynamicTokensEnabled: false,
9666 outputCst: true,
9667 errorMessageProvider: defaultParserErrorProvider,
9668 nodeLocationTracking: "none",
9669 traceInitPerf: false,
9670 skipValidations: false,
9671 });
9672 const DEFAULT_RULE_CONFIG = Object.freeze({
9673 recoveryValueFunc: () => undefined,
9674 resyncEnabled: true,
9675 });
9676 var ParserDefinitionErrorType;
9677 (function (ParserDefinitionErrorType) {
9678 ParserDefinitionErrorType[ParserDefinitionErrorType["INVALID_RULE_NAME"] = 0] = "INVALID_RULE_NAME";
9679 ParserDefinitionErrorType[ParserDefinitionErrorType["DUPLICATE_RULE_NAME"] = 1] = "DUPLICATE_RULE_NAME";
9680 ParserDefinitionErrorType[ParserDefinitionErrorType["INVALID_RULE_OVERRIDE"] = 2] = "INVALID_RULE_OVERRIDE";
9681 ParserDefinitionErrorType[ParserDefinitionErrorType["DUPLICATE_PRODUCTIONS"] = 3] = "DUPLICATE_PRODUCTIONS";
9682 ParserDefinitionErrorType[ParserDefinitionErrorType["UNRESOLVED_SUBRULE_REF"] = 4] = "UNRESOLVED_SUBRULE_REF";
9683 ParserDefinitionErrorType[ParserDefinitionErrorType["LEFT_RECURSION"] = 5] = "LEFT_RECURSION";
9684 ParserDefinitionErrorType[ParserDefinitionErrorType["NONE_LAST_EMPTY_ALT"] = 6] = "NONE_LAST_EMPTY_ALT";
9685 ParserDefinitionErrorType[ParserDefinitionErrorType["AMBIGUOUS_ALTS"] = 7] = "AMBIGUOUS_ALTS";
9686 ParserDefinitionErrorType[ParserDefinitionErrorType["CONFLICT_TOKENS_RULES_NAMESPACE"] = 8] = "CONFLICT_TOKENS_RULES_NAMESPACE";
9687 ParserDefinitionErrorType[ParserDefinitionErrorType["INVALID_TOKEN_NAME"] = 9] = "INVALID_TOKEN_NAME";
9688 ParserDefinitionErrorType[ParserDefinitionErrorType["NO_NON_EMPTY_LOOKAHEAD"] = 10] = "NO_NON_EMPTY_LOOKAHEAD";
9689 ParserDefinitionErrorType[ParserDefinitionErrorType["AMBIGUOUS_PREFIX_ALTS"] = 11] = "AMBIGUOUS_PREFIX_ALTS";
9690 ParserDefinitionErrorType[ParserDefinitionErrorType["TOO_MANY_ALTS"] = 12] = "TOO_MANY_ALTS";
9691 ParserDefinitionErrorType[ParserDefinitionErrorType["CUSTOM_LOOKAHEAD_VALIDATION"] = 13] = "CUSTOM_LOOKAHEAD_VALIDATION";
9692 })(ParserDefinitionErrorType || (ParserDefinitionErrorType = {}));
9693 function EMPTY_ALT(value = undefined) {
9694 return function () {
9695 return value;
9696 };
9697 }
9698 class Parser {
9699 /**
9700 * @deprecated use the **instance** method with the same name instead
9701 */
9702 static performSelfAnalysis(parserInstance) {
9703 throw Error("The **static** `performSelfAnalysis` method has been deprecated." +
9704 "\t\nUse the **instance** method with the same name instead.");
9705 }
9706 performSelfAnalysis() {
9707 this.TRACE_INIT("performSelfAnalysis", () => {
9708 let defErrorsMsgs;
9709 this.selfAnalysisDone = true;
9710 const className = this.className;
9711 this.TRACE_INIT("toFastProps", () => {
9712 // Without this voodoo magic the parser would be x3-x4 slower
9713 // It seems it is better to invoke `toFastProperties` **before**
9714 // Any manipulations of the `this` object done during the recording phase.
9715 toFastProperties(this);
9716 });
9717 this.TRACE_INIT("Grammar Recording", () => {
9718 try {
9719 this.enableRecording();
9720 // Building the GAST
9721 (0,forEach/* default */.Z)(this.definedRulesNames, (currRuleName) => {
9722 const wrappedRule = this[currRuleName];
9723 const originalGrammarAction = wrappedRule["originalGrammarAction"];
9724 let recordedRuleGast;
9725 this.TRACE_INIT(`${currRuleName} Rule`, () => {
9726 recordedRuleGast = this.topLevelRuleRecord(currRuleName, originalGrammarAction);
9727 });
9728 this.gastProductionsCache[currRuleName] = recordedRuleGast;
9729 });
9730 }
9731 finally {
9732 this.disableRecording();
9733 }
9734 });
9735 let resolverErrors = [];
9736 this.TRACE_INIT("Grammar Resolving", () => {
9737 resolverErrors = gast_resolver_public_resolveGrammar({
9738 rules: (0,values/* default */.Z)(this.gastProductionsCache),
9739 });
9740 this.definitionErrors = this.definitionErrors.concat(resolverErrors);
9741 });
9742 this.TRACE_INIT("Grammar Validations", () => {
9743 // only perform additional grammar validations IFF no resolving errors have occurred.
9744 // as unresolved grammar may lead to unhandled runtime exceptions in the follow up validations.
9745 if ((0,isEmpty/* default */.Z)(resolverErrors) && this.skipValidations === false) {
9746 const validationErrors = gast_resolver_public_validateGrammar({
9747 rules: (0,values/* default */.Z)(this.gastProductionsCache),
9748 tokenTypes: (0,values/* default */.Z)(this.tokensMap),
9749 errMsgProvider: defaultGrammarValidatorErrorProvider,
9750 grammarName: className,
9751 });
9752 const lookaheadValidationErrors = validateLookahead({
9753 lookaheadStrategy: this.lookaheadStrategy,
9754 rules: (0,values/* default */.Z)(this.gastProductionsCache),
9755 tokenTypes: (0,values/* default */.Z)(this.tokensMap),
9756 grammarName: className,
9757 });
9758 this.definitionErrors = this.definitionErrors.concat(validationErrors, lookaheadValidationErrors);
9759 }
9760 });
9761 // this analysis may fail if the grammar is not perfectly valid
9762 if ((0,isEmpty/* default */.Z)(this.definitionErrors)) {
9763 // The results of these computations are not needed unless error recovery is enabled.
9764 if (this.recoveryEnabled) {
9765 this.TRACE_INIT("computeAllProdsFollows", () => {
9766 const allFollows = computeAllProdsFollows((0,values/* default */.Z)(this.gastProductionsCache));
9767 this.resyncFollows = allFollows;
9768 });
9769 }
9770 this.TRACE_INIT("ComputeLookaheadFunctions", () => {
9771 var _a, _b;
9772 (_b = (_a = this.lookaheadStrategy).initialize) === null || _b === void 0 ? void 0 : _b.call(_a, {
9773 rules: (0,values/* default */.Z)(this.gastProductionsCache),
9774 });
9775 this.preComputeLookaheadFunctions((0,values/* default */.Z)(this.gastProductionsCache));
9776 });
9777 }
9778 if (!Parser.DEFER_DEFINITION_ERRORS_HANDLING &&
9779 !(0,isEmpty/* default */.Z)(this.definitionErrors)) {
9780 defErrorsMsgs = (0,map/* default */.Z)(this.definitionErrors, (defError) => defError.message);
9781 throw new Error(`Parser Definition Errors detected:\n ${defErrorsMsgs.join("\n-------------------------------\n")}`);
9782 }
9783 });
9784 }
9785 constructor(tokenVocabulary, config) {
9786 this.definitionErrors = [];
9787 this.selfAnalysisDone = false;
9788 const that = this;
9789 that.initErrorHandler(config);
9790 that.initLexerAdapter();
9791 that.initLooksAhead(config);
9792 that.initRecognizerEngine(tokenVocabulary, config);
9793 that.initRecoverable(config);
9794 that.initTreeBuilder(config);
9795 that.initContentAssist();
9796 that.initGastRecorder(config);
9797 that.initPerformanceTracer(config);
9798 if ((0,has/* default */.Z)(config, "ignoredIssues")) {
9799 throw new Error("The <ignoredIssues> IParserConfig property has been deprecated.\n\t" +
9800 "Please use the <IGNORE_AMBIGUITIES> flag on the relevant DSL method instead.\n\t" +
9801 "See: https://chevrotain.io/docs/guide/resolving_grammar_errors.html#IGNORING_AMBIGUITIES\n\t" +
9802 "For further details.");
9803 }
9804 this.skipValidations = (0,has/* default */.Z)(config, "skipValidations")
9805 ? config.skipValidations // casting assumes the end user passing the correct type
9806 : DEFAULT_PARSER_CONFIG.skipValidations;
9807 }
9808 }
9809 // Set this flag to true if you don't want the Parser to throw error when problems in it's definition are detected.
9810 // (normally during the parser's constructor).
9811 // This is a design time flag, it will not affect the runtime error handling of the parser, just design time errors,
9812 // for example: duplicate rule names, referencing an unresolved subrule, ect...
9813 // This flag should not be enabled during normal usage, it is used in special situations, for example when
9814 // needing to display the parser definition errors in some GUI(online playground).
9815 Parser.DEFER_DEFINITION_ERRORS_HANDLING = false;
9816 applyMixins(Parser, [
9817 Recoverable,
9818 LooksAhead,
9819 TreeBuilder,
9820 LexerAdapter,
9821 RecognizerEngine,
9822 RecognizerApi,
9823 ErrorHandler,
9824 ContentAssist,
9825 GastRecorder,
9826 PerformanceTracer,
9827 ]);
9828 class CstParser extends (/* unused pure expression or super */ null && (Parser)) {
9829 constructor(tokenVocabulary, config = DEFAULT_PARSER_CONFIG) {
9830 const configClone = clone(config);
9831 configClone.outputCst = true;
9832 super(tokenVocabulary, configClone);
9833 }
9834 }
9835 class EmbeddedActionsParser extends Parser {
9836 constructor(tokenVocabulary, config = DEFAULT_PARSER_CONFIG) {
9837 const configClone = (0,lodash_es_clone/* default */.Z)(config);
9838 configClone.outputCst = false;
9839 super(tokenVocabulary, configClone);
9840 }
9841 }
9842 //# sourceMappingURL=parser.js.map
9843 ;// CONCATENATED MODULE: ../node_modules/@chevrotain/cst-dts-gen/lib/src/api.js
9844
9845
9846 const defaultOptions = {
9847 includeVisitorInterface: true,
9848 visitorInterfaceName: "ICstNodeVisitor",
9849 };
9850 function generateCstDts(productions, options) {
9851 const effectiveOptions = Object.assign(Object.assign({}, defaultOptions), options);
9852 const model = buildModel(productions);
9853 return genDts(model, effectiveOptions);
9854 }
9855 //# sourceMappingURL=api.js.map
9856 ;// CONCATENATED MODULE: ../node_modules/chevrotain/lib/src/api.js
9857 /* istanbul ignore file - tricky to import some things from this module during testing */
9858 // semantic version
9859
9860
9861
9862 // Tokens utilities
9863
9864 // Lookahead
9865
9866
9867 // Other Utilities
9868
9869
9870
9871 // grammar reflection API
9872
9873 // GAST Utilities
9874
9875
9876 /* istanbul ignore next */
9877 function clearCache() {
9878 console.warn("The clearCache function was 'soft' removed from the Chevrotain API." +
9879 "\n\t It performs no action other than printing this message." +
9880 "\n\t Please avoid using it as it will be completely removed in the future");
9881 }
9882
9883 class api_Parser {
9884 constructor() {
9885 throw new Error("The Parser class has been deprecated, use CstParser or EmbeddedActionsParser instead.\t\n" +
9886 "See: https://chevrotain.io/docs/changes/BREAKING_CHANGES.html#_7-0-0");
9887 }
9888 }
9889 //# sourceMappingURL=api.js.map
9890
9891 /***/ }),
9892
9893 /***/ 73001:
9894 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
9895
9896 "use strict";
9897
9898 // EXPORTS
9899 __webpack_require__.d(__webpack_exports__, {
9900 Q: () => (/* binding */ createDefaultCoreModule),
9901 T: () => (/* binding */ createDefaultSharedCoreModule)
9902 });
9903
9904 // EXTERNAL MODULE: ../node_modules/langium/lib/utils/cst-utils.js
9905 var cst_utils = __webpack_require__(13871);
9906 // EXTERNAL MODULE: ../node_modules/langium/lib/utils/grammar-utils.js
9907 var grammar_utils = __webpack_require__(30447);
9908 // EXTERNAL MODULE: ../node_modules/langium/lib/utils/regexp-utils.js
9909 var regexp_utils = __webpack_require__(43078);
9910 // EXTERNAL MODULE: ../node_modules/langium/lib/languages/generated/ast.js
9911 var ast = __webpack_require__(34905);
9912 ;// CONCATENATED MODULE: ../node_modules/langium/lib/languages/grammar-config.js
9913 /******************************************************************************
9914 * Copyright 2021 TypeFox GmbH
9915 * This program and the accompanying materials are made available under the
9916 * terms of the MIT License, which is available in the project root.
9917 ******************************************************************************/
9918
9919
9920
9921
9922 /**
9923 * Create the default grammar configuration (used by `createDefaultModule`). This can be overridden in a
9924 * language-specific module.
9925 */
9926 function createGrammarConfig(services) {
9927 const rules = [];
9928 const grammar = services.Grammar;
9929 for (const rule of grammar.rules) {
9930 if ((0,ast/* isTerminalRule */.MS)(rule) && (0,grammar_utils/* isCommentTerminal */.md)(rule) && (0,regexp_utils/* isMultilineComment */.Rn)((0,grammar_utils/* terminalRegex */.s1)(rule))) {
9931 rules.push(rule.name);
9932 }
9933 }
9934 return {
9935 multilineCommentRules: rules,
9936 nameRegexp: cst_utils/* DefaultNameRegexp */.uz
9937 };
9938 }
9939 //# sourceMappingURL=grammar-config.js.map
9940 // EXTERNAL MODULE: ../node_modules/chevrotain/lib/src/api.js + 67 modules
9941 var api = __webpack_require__(34326);
9942 // EXTERNAL MODULE: ../node_modules/lodash-es/map.js
9943 var map = __webpack_require__(12930);
9944 // EXTERNAL MODULE: ../node_modules/lodash-es/filter.js
9945 var filter = __webpack_require__(11382);
9946 ;// CONCATENATED MODULE: ../node_modules/chevrotain-allstar/lib/atn.js
9947 /******************************************************************************
9948 * Copyright 2022 TypeFox GmbH
9949 * This program and the accompanying materials are made available under the
9950 * terms of the MIT License, which is available in the project root.
9951 ******************************************************************************/
9952
9953
9954
9955 function buildATNKey(rule, type, occurrence) {
9956 return `${rule.name}_${type}_${occurrence}`;
9957 }
9958 const ATN_INVALID_TYPE = 0;
9959 const ATN_BASIC = 1;
9960 const ATN_RULE_START = 2;
9961 const ATN_PLUS_BLOCK_START = 4;
9962 const ATN_STAR_BLOCK_START = 5;
9963 // Currently unused as the ATN is not used for lexing
9964 const ATN_TOKEN_START = 6;
9965 const ATN_RULE_STOP = 7;
9966 const ATN_BLOCK_END = 8;
9967 const ATN_STAR_LOOP_BACK = 9;
9968 const ATN_STAR_LOOP_ENTRY = 10;
9969 const ATN_PLUS_LOOP_BACK = 11;
9970 const ATN_LOOP_END = 12;
9971 class AbstractTransition {
9972 constructor(target) {
9973 this.target = target;
9974 }
9975 isEpsilon() {
9976 return false;
9977 }
9978 }
9979 class AtomTransition extends AbstractTransition {
9980 constructor(target, tokenType) {
9981 super(target);
9982 this.tokenType = tokenType;
9983 }
9984 }
9985 class EpsilonTransition extends AbstractTransition {
9986 constructor(target) {
9987 super(target);
9988 }
9989 isEpsilon() {
9990 return true;
9991 }
9992 }
9993 class RuleTransition extends AbstractTransition {
9994 constructor(ruleStart, rule, followState) {
9995 super(ruleStart);
9996 this.rule = rule;
9997 this.followState = followState;
9998 }
9999 isEpsilon() {
10000 return true;
10001 }
10002 }
10003 function createATN(rules) {
10004 const atn = {
10005 decisionMap: {},
10006 decisionStates: [],
10007 ruleToStartState: new Map(),
10008 ruleToStopState: new Map(),
10009 states: []
10010 };
10011 createRuleStartAndStopATNStates(atn, rules);
10012 const ruleLength = rules.length;
10013 for (let i = 0; i < ruleLength; i++) {
10014 const rule = rules[i];
10015 const ruleBlock = block(atn, rule, rule);
10016 if (ruleBlock === undefined) {
10017 continue;
10018 }
10019 buildRuleHandle(atn, rule, ruleBlock);
10020 }
10021 return atn;
10022 }
10023 function createRuleStartAndStopATNStates(atn, rules) {
10024 const ruleLength = rules.length;
10025 for (let i = 0; i < ruleLength; i++) {
10026 const rule = rules[i];
10027 const start = newState(atn, rule, undefined, {
10028 type: ATN_RULE_START
10029 });
10030 const stop = newState(atn, rule, undefined, {
10031 type: ATN_RULE_STOP
10032 });
10033 start.stop = stop;
10034 atn.ruleToStartState.set(rule, start);
10035 atn.ruleToStopState.set(rule, stop);
10036 }
10037 }
10038 function atom(atn, rule, production) {
10039 if (production instanceof api/* Terminal */.oI) {
10040 return tokenRef(atn, rule, production.terminalType, production);
10041 }
10042 else if (production instanceof api/* NonTerminal */.Sj) {
10043 return ruleRef(atn, rule, production);
10044 }
10045 else if (production instanceof api/* Alternation */.ue) {
10046 return alternation(atn, rule, production);
10047 }
10048 else if (production instanceof api/* Option */.Wx) {
10049 return atn_option(atn, rule, production);
10050 }
10051 else if (production instanceof api/* Repetition */.hI) {
10052 return repetition(atn, rule, production);
10053 }
10054 else if (production instanceof api/* RepetitionWithSeparator */.pT) {
10055 return repetitionSep(atn, rule, production);
10056 }
10057 else if (production instanceof api/* RepetitionMandatory */.ej) {
10058 return repetitionMandatory(atn, rule, production);
10059 }
10060 else if (production instanceof api/* RepetitionMandatoryWithSeparator */.fK) {
10061 return repetitionMandatorySep(atn, rule, production);
10062 }
10063 else {
10064 return block(atn, rule, production);
10065 }
10066 }
10067 function repetition(atn, rule, repetition) {
10068 const starState = newState(atn, rule, repetition, {
10069 type: ATN_STAR_BLOCK_START
10070 });
10071 defineDecisionState(atn, starState);
10072 const handle = makeAlts(atn, rule, starState, repetition, block(atn, rule, repetition));
10073 return star(atn, rule, repetition, handle);
10074 }
10075 function repetitionSep(atn, rule, repetition) {
10076 const starState = newState(atn, rule, repetition, {
10077 type: ATN_STAR_BLOCK_START
10078 });
10079 defineDecisionState(atn, starState);
10080 const handle = makeAlts(atn, rule, starState, repetition, block(atn, rule, repetition));
10081 const sep = tokenRef(atn, rule, repetition.separator, repetition);
10082 return star(atn, rule, repetition, handle, sep);
10083 }
10084 function repetitionMandatory(atn, rule, repetition) {
10085 const plusState = newState(atn, rule, repetition, {
10086 type: ATN_PLUS_BLOCK_START
10087 });
10088 defineDecisionState(atn, plusState);
10089 const handle = makeAlts(atn, rule, plusState, repetition, block(atn, rule, repetition));
10090 return plus(atn, rule, repetition, handle);
10091 }
10092 function repetitionMandatorySep(atn, rule, repetition) {
10093 const plusState = newState(atn, rule, repetition, {
10094 type: ATN_PLUS_BLOCK_START
10095 });
10096 defineDecisionState(atn, plusState);
10097 const handle = makeAlts(atn, rule, plusState, repetition, block(atn, rule, repetition));
10098 const sep = tokenRef(atn, rule, repetition.separator, repetition);
10099 return plus(atn, rule, repetition, handle, sep);
10100 }
10101 function alternation(atn, rule, alternation) {
10102 const start = newState(atn, rule, alternation, {
10103 type: ATN_BASIC
10104 });
10105 defineDecisionState(atn, start);
10106 const alts = (0,map/* default */.Z)(alternation.definition, (e) => atom(atn, rule, e));
10107 const handle = makeAlts(atn, rule, start, alternation, ...alts);
10108 return handle;
10109 }
10110 function atn_option(atn, rule, option) {
10111 const start = newState(atn, rule, option, {
10112 type: ATN_BASIC
10113 });
10114 defineDecisionState(atn, start);
10115 const handle = makeAlts(atn, rule, start, option, block(atn, rule, option));
10116 return optional(atn, rule, option, handle);
10117 }
10118 function block(atn, rule, block) {
10119 const handles = (0,filter/* default */.Z)((0,map/* default */.Z)(block.definition, (e) => atom(atn, rule, e)), (e) => e !== undefined);
10120 if (handles.length === 1) {
10121 return handles[0];
10122 }
10123 else if (handles.length === 0) {
10124 return undefined;
10125 }
10126 else {
10127 return makeBlock(atn, handles);
10128 }
10129 }
10130 function plus(atn, rule, plus, handle, sep) {
10131 const blkStart = handle.left;
10132 const blkEnd = handle.right;
10133 const loop = newState(atn, rule, plus, {
10134 type: ATN_PLUS_LOOP_BACK
10135 });
10136 defineDecisionState(atn, loop);
10137 const end = newState(atn, rule, plus, {
10138 type: ATN_LOOP_END
10139 });
10140 blkStart.loopback = loop;
10141 end.loopback = loop;
10142 atn.decisionMap[buildATNKey(rule, sep ? 'RepetitionMandatoryWithSeparator' : 'RepetitionMandatory', plus.idx)] = loop;
10143 epsilon(blkEnd, loop); // block can see loop back
10144 // Depending on whether we have a separator we put the exit transition at index 1 or 0
10145 // This influences the chosen option in the lookahead DFA
10146 if (sep === undefined) {
10147 epsilon(loop, blkStart); // loop back to start
10148 epsilon(loop, end); // exit
10149 }
10150 else {
10151 epsilon(loop, end); // exit
10152 // loop back to start with separator
10153 epsilon(loop, sep.left);
10154 epsilon(sep.right, blkStart);
10155 }
10156 return {
10157 left: blkStart,
10158 right: end
10159 };
10160 }
10161 function star(atn, rule, star, handle, sep) {
10162 const start = handle.left;
10163 const end = handle.right;
10164 const entry = newState(atn, rule, star, {
10165 type: ATN_STAR_LOOP_ENTRY
10166 });
10167 defineDecisionState(atn, entry);
10168 const loopEnd = newState(atn, rule, star, {
10169 type: ATN_LOOP_END
10170 });
10171 const loop = newState(atn, rule, star, {
10172 type: ATN_STAR_LOOP_BACK
10173 });
10174 entry.loopback = loop;
10175 loopEnd.loopback = loop;
10176 epsilon(entry, start); // loop enter edge (alt 2)
10177 epsilon(entry, loopEnd); // bypass loop edge (alt 1)
10178 epsilon(end, loop); // block end hits loop back
10179 if (sep !== undefined) {
10180 epsilon(loop, loopEnd); // end loop
10181 // loop back to start of handle using separator
10182 epsilon(loop, sep.left);
10183 epsilon(sep.right, start);
10184 }
10185 else {
10186 epsilon(loop, entry); // loop back to entry/exit decision
10187 }
10188 atn.decisionMap[buildATNKey(rule, sep ? 'RepetitionWithSeparator' : 'Repetition', star.idx)] = entry;
10189 return {
10190 left: entry,
10191 right: loopEnd
10192 };
10193 }
10194 function optional(atn, rule, optional, handle) {
10195 const start = handle.left;
10196 const end = handle.right;
10197 epsilon(start, end);
10198 atn.decisionMap[buildATNKey(rule, 'Option', optional.idx)] = start;
10199 return handle;
10200 }
10201 function defineDecisionState(atn, state) {
10202 atn.decisionStates.push(state);
10203 state.decision = atn.decisionStates.length - 1;
10204 return state.decision;
10205 }
10206 function makeAlts(atn, rule, start, production, ...alts) {
10207 const end = newState(atn, rule, production, {
10208 type: ATN_BLOCK_END,
10209 start
10210 });
10211 start.end = end;
10212 for (const alt of alts) {
10213 if (alt !== undefined) {
10214 // hook alts up to decision block
10215 epsilon(start, alt.left);
10216 epsilon(alt.right, end);
10217 }
10218 else {
10219 epsilon(start, end);
10220 }
10221 }
10222 const handle = {
10223 left: start,
10224 right: end
10225 };
10226 atn.decisionMap[buildATNKey(rule, getProdType(production), production.idx)] = start;
10227 return handle;
10228 }
10229 function getProdType(production) {
10230 if (production instanceof api/* Alternation */.ue) {
10231 return 'Alternation';
10232 }
10233 else if (production instanceof api/* Option */.Wx) {
10234 return 'Option';
10235 }
10236 else if (production instanceof api/* Repetition */.hI) {
10237 return 'Repetition';
10238 }
10239 else if (production instanceof api/* RepetitionWithSeparator */.pT) {
10240 return 'RepetitionWithSeparator';
10241 }
10242 else if (production instanceof api/* RepetitionMandatory */.ej) {
10243 return 'RepetitionMandatory';
10244 }
10245 else if (production instanceof api/* RepetitionMandatoryWithSeparator */.fK) {
10246 return 'RepetitionMandatoryWithSeparator';
10247 }
10248 else {
10249 throw new Error('Invalid production type encountered');
10250 }
10251 }
10252 function makeBlock(atn, alts) {
10253 const altsLength = alts.length;
10254 for (let i = 0; i < altsLength - 1; i++) {
10255 const handle = alts[i];
10256 let transition;
10257 if (handle.left.transitions.length === 1) {
10258 transition = handle.left.transitions[0];
10259 }
10260 const isRuleTransition = transition instanceof RuleTransition;
10261 const ruleTransition = transition;
10262 const next = alts[i + 1].left;
10263 if (handle.left.type === ATN_BASIC &&
10264 handle.right.type === ATN_BASIC &&
10265 transition !== undefined &&
10266 ((isRuleTransition && ruleTransition.followState === handle.right) ||
10267 transition.target === handle.right)) {
10268 // we can avoid epsilon edge to next element
10269 if (isRuleTransition) {
10270 ruleTransition.followState = next;
10271 }
10272 else {
10273 transition.target = next;
10274 }
10275 removeState(atn, handle.right); // we skipped over this state
10276 }
10277 else {
10278 // need epsilon if previous block's right end node is complex
10279 epsilon(handle.right, next);
10280 }
10281 }
10282 const first = alts[0];
10283 const last = alts[altsLength - 1];
10284 return {
10285 left: first.left,
10286 right: last.right
10287 };
10288 }
10289 function tokenRef(atn, rule, tokenType, production) {
10290 const left = newState(atn, rule, production, {
10291 type: ATN_BASIC
10292 });
10293 const right = newState(atn, rule, production, {
10294 type: ATN_BASIC
10295 });
10296 addTransition(left, new AtomTransition(right, tokenType));
10297 return {
10298 left,
10299 right
10300 };
10301 }
10302 function ruleRef(atn, currentRule, nonTerminal) {
10303 const rule = nonTerminal.referencedRule;
10304 const start = atn.ruleToStartState.get(rule);
10305 const left = newState(atn, currentRule, nonTerminal, {
10306 type: ATN_BASIC
10307 });
10308 const right = newState(atn, currentRule, nonTerminal, {
10309 type: ATN_BASIC
10310 });
10311 const call = new RuleTransition(start, rule, right);
10312 addTransition(left, call);
10313 return {
10314 left,
10315 right
10316 };
10317 }
10318 function buildRuleHandle(atn, rule, block) {
10319 const start = atn.ruleToStartState.get(rule);
10320 epsilon(start, block.left);
10321 const stop = atn.ruleToStopState.get(rule);
10322 epsilon(block.right, stop);
10323 const handle = {
10324 left: start,
10325 right: stop
10326 };
10327 return handle;
10328 }
10329 function epsilon(a, b) {
10330 const transition = new EpsilonTransition(b);
10331 addTransition(a, transition);
10332 }
10333 function newState(atn, rule, production, partial) {
10334 const t = Object.assign({ atn,
10335 production, epsilonOnlyTransitions: false, rule, transitions: [], nextTokenWithinRule: [], stateNumber: atn.states.length }, partial);
10336 atn.states.push(t);
10337 return t;
10338 }
10339 function addTransition(state, transition) {
10340 // A single ATN state can only contain epsilon transitions or non-epsilon transitions
10341 // Because they are never mixed, only setting the property for the first transition is fine
10342 if (state.transitions.length === 0) {
10343 state.epsilonOnlyTransitions = transition.isEpsilon();
10344 }
10345 state.transitions.push(transition);
10346 }
10347 function removeState(atn, state) {
10348 atn.states.splice(atn.states.indexOf(state), 1);
10349 }
10350 //# sourceMappingURL=atn.js.map
10351 ;// CONCATENATED MODULE: ../node_modules/chevrotain-allstar/lib/dfa.js
10352 /******************************************************************************
10353 * Copyright 2022 TypeFox GmbH
10354 * This program and the accompanying materials are made available under the
10355 * terms of the MIT License, which is available in the project root.
10356 ******************************************************************************/
10357
10358 const DFA_ERROR = {};
10359 class ATNConfigSet {
10360 constructor() {
10361 this.map = {};
10362 this.configs = [];
10363 }
10364 get size() {
10365 return this.configs.length;
10366 }
10367 finalize() {
10368 // Empties the map to free up memory
10369 this.map = {};
10370 }
10371 add(config) {
10372 const key = getATNConfigKey(config);
10373 // Only add configs which don't exist in our map already
10374 // While this does not influence the actual algorithm, adding them anyway would massively increase memory consumption
10375 if (!(key in this.map)) {
10376 this.map[key] = this.configs.length;
10377 this.configs.push(config);
10378 }
10379 }
10380 get elements() {
10381 return this.configs;
10382 }
10383 get alts() {
10384 return (0,map/* default */.Z)(this.configs, (e) => e.alt);
10385 }
10386 get key() {
10387 let value = "";
10388 for (const k in this.map) {
10389 value += k + ":";
10390 }
10391 return value;
10392 }
10393 }
10394 function getATNConfigKey(config, alt = true) {
10395 return `${alt ? `a${config.alt}` : ""}s${config.state.stateNumber}:${config.stack.map((e) => e.stateNumber.toString()).join("_")}`;
10396 }
10397 //# sourceMappingURL=dfa.js.map
10398 // EXTERNAL MODULE: ../node_modules/lodash-es/min.js
10399 var min = __webpack_require__(18519);
10400 // EXTERNAL MODULE: ../node_modules/lodash-es/flatMap.js
10401 var flatMap = __webpack_require__(34134);
10402 // EXTERNAL MODULE: ../node_modules/lodash-es/_baseIteratee.js + 15 modules
10403 var _baseIteratee = __webpack_require__(86494);
10404 // EXTERNAL MODULE: ../node_modules/lodash-es/_baseUniq.js + 1 modules
10405 var _baseUniq = __webpack_require__(99633);
10406 ;// CONCATENATED MODULE: ../node_modules/lodash-es/uniqBy.js
10407
10408
10409
10410 /**
10411 * This method is like `_.uniq` except that it accepts `iteratee` which is
10412 * invoked for each element in `array` to generate the criterion by which
10413 * uniqueness is computed. The order of result values is determined by the
10414 * order they occur in the array. The iteratee is invoked with one argument:
10415 * (value).
10416 *
10417 * @static
10418 * @memberOf _
10419 * @since 4.0.0
10420 * @category Array
10421 * @param {Array} array The array to inspect.
10422 * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
10423 * @returns {Array} Returns the new duplicate free array.
10424 * @example
10425 *
10426 * _.uniqBy([2.1, 1.2, 2.3], Math.floor);
10427 * // => [2.1, 1.2]
10428 *
10429 * // The `_.property` iteratee shorthand.
10430 * _.uniqBy([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x');
10431 * // => [{ 'x': 1 }, { 'x': 2 }]
10432 */
10433 function uniqBy(array, iteratee) {
10434 return (array && array.length) ? (0,_baseUniq/* default */.Z)(array, (0,_baseIteratee/* default */.Z)(iteratee, 2)) : [];
10435 }
10436
10437 /* harmony default export */ const lodash_es_uniqBy = (uniqBy);
10438
10439 // EXTERNAL MODULE: ../node_modules/lodash-es/flatten.js
10440 var flatten = __webpack_require__(28099);
10441 // EXTERNAL MODULE: ../node_modules/lodash-es/forEach.js
10442 var forEach = __webpack_require__(21845);
10443 // EXTERNAL MODULE: ../node_modules/lodash-es/isEmpty.js
10444 var isEmpty = __webpack_require__(66400);
10445 // EXTERNAL MODULE: ../node_modules/lodash-es/reduce.js + 2 modules
10446 var reduce = __webpack_require__(99413);
10447 ;// CONCATENATED MODULE: ../node_modules/chevrotain-allstar/lib/all-star-lookahead.js
10448 /******************************************************************************
10449 * Copyright 2022 TypeFox GmbH
10450 * This program and the accompanying materials are made available under the
10451 * terms of the MIT License, which is available in the project root.
10452 ******************************************************************************/
10453
10454
10455
10456
10457
10458
10459
10460
10461
10462
10463
10464 function createDFACache(startState, decision) {
10465 const map = {};
10466 return (predicateSet) => {
10467 const key = predicateSet.toString();
10468 let existing = map[key];
10469 if (existing !== undefined) {
10470 return existing;
10471 }
10472 else {
10473 existing = {
10474 atnStartState: startState,
10475 decision,
10476 states: {}
10477 };
10478 map[key] = existing;
10479 return existing;
10480 }
10481 };
10482 }
10483 class PredicateSet {
10484 constructor() {
10485 this.predicates = [];
10486 }
10487 is(index) {
10488 return index >= this.predicates.length || this.predicates[index];
10489 }
10490 set(index, value) {
10491 this.predicates[index] = value;
10492 }
10493 toString() {
10494 let value = "";
10495 const size = this.predicates.length;
10496 for (let i = 0; i < size; i++) {
10497 value += this.predicates[i] === true ? "1" : "0";
10498 }
10499 return value;
10500 }
10501 }
10502 const EMPTY_PREDICATES = new PredicateSet();
10503 class LLStarLookaheadStrategy extends api/* LLkLookaheadStrategy */.dV {
10504 constructor(options) {
10505 var _a;
10506 super();
10507 this.logging = (_a = options === null || options === void 0 ? void 0 : options.logging) !== null && _a !== void 0 ? _a : ((message) => console.log(message));
10508 }
10509 initialize(options) {
10510 this.atn = createATN(options.rules);
10511 this.dfas = initATNSimulator(this.atn);
10512 }
10513 validateAmbiguousAlternationAlternatives() {
10514 return [];
10515 }
10516 validateEmptyOrAlternatives() {
10517 return [];
10518 }
10519 buildLookaheadForAlternation(options) {
10520 const { prodOccurrence, rule, hasPredicates, dynamicTokensEnabled } = options;
10521 const dfas = this.dfas;
10522 const logging = this.logging;
10523 const key = buildATNKey(rule, 'Alternation', prodOccurrence);
10524 const decisionState = this.atn.decisionMap[key];
10525 const decisionIndex = decisionState.decision;
10526 const partialAlts = (0,map/* default */.Z)((0,api/* getLookaheadPaths */.oC)({
10527 maxLookahead: 1,
10528 occurrence: prodOccurrence,
10529 prodType: "Alternation",
10530 rule: rule
10531 }), (currAlt) => (0,map/* default */.Z)(currAlt, (path) => path[0]));
10532 if (isLL1Sequence(partialAlts, false) && !dynamicTokensEnabled) {
10533 const choiceToAlt = (0,reduce/* default */.Z)(partialAlts, (result, currAlt, idx) => {
10534 (0,forEach/* default */.Z)(currAlt, (currTokType) => {
10535 if (currTokType) {
10536 result[currTokType.tokenTypeIdx] = idx;
10537 (0,forEach/* default */.Z)(currTokType.categoryMatches, (currExtendingType) => {
10538 result[currExtendingType] = idx;
10539 });
10540 }
10541 });
10542 return result;
10543 }, {});
10544 if (hasPredicates) {
10545 return function (orAlts) {
10546 var _a;
10547 const nextToken = this.LA(1);
10548 const prediction = choiceToAlt[nextToken.tokenTypeIdx];
10549 if (orAlts !== undefined && prediction !== undefined) {
10550 const gate = (_a = orAlts[prediction]) === null || _a === void 0 ? void 0 : _a.GATE;
10551 if (gate !== undefined && gate.call(this) === false) {
10552 return undefined;
10553 }
10554 }
10555 return prediction;
10556 };
10557 }
10558 else {
10559 return function () {
10560 const nextToken = this.LA(1);
10561 return choiceToAlt[nextToken.tokenTypeIdx];
10562 };
10563 }
10564 }
10565 else if (hasPredicates) {
10566 return function (orAlts) {
10567 const predicates = new PredicateSet();
10568 const length = orAlts === undefined ? 0 : orAlts.length;
10569 for (let i = 0; i < length; i++) {
10570 const gate = orAlts === null || orAlts === void 0 ? void 0 : orAlts[i].GATE;
10571 predicates.set(i, gate === undefined || gate.call(this));
10572 }
10573 const result = adaptivePredict.call(this, dfas, decisionIndex, predicates, logging);
10574 return typeof result === 'number' ? result : undefined;
10575 };
10576 }
10577 else {
10578 return function () {
10579 const result = adaptivePredict.call(this, dfas, decisionIndex, EMPTY_PREDICATES, logging);
10580 return typeof result === 'number' ? result : undefined;
10581 };
10582 }
10583 }
10584 buildLookaheadForOptional(options) {
10585 const { prodOccurrence, rule, prodType, dynamicTokensEnabled } = options;
10586 const dfas = this.dfas;
10587 const logging = this.logging;
10588 const key = buildATNKey(rule, prodType, prodOccurrence);
10589 const decisionState = this.atn.decisionMap[key];
10590 const decisionIndex = decisionState.decision;
10591 const alts = (0,map/* default */.Z)((0,api/* getLookaheadPaths */.oC)({
10592 maxLookahead: 1,
10593 occurrence: prodOccurrence,
10594 prodType,
10595 rule
10596 }), (e) => {
10597 return (0,map/* default */.Z)(e, (g) => g[0]);
10598 });
10599 if (isLL1Sequence(alts) && alts[0][0] && !dynamicTokensEnabled) {
10600 const alt = alts[0];
10601 const singleTokensTypes = (0,flatten/* default */.Z)(alt);
10602 if (singleTokensTypes.length === 1 &&
10603 (0,isEmpty/* default */.Z)(singleTokensTypes[0].categoryMatches)) {
10604 const expectedTokenType = singleTokensTypes[0];
10605 const expectedTokenUniqueKey = expectedTokenType.tokenTypeIdx;
10606 return function () {
10607 return this.LA(1).tokenTypeIdx === expectedTokenUniqueKey;
10608 };
10609 }
10610 else {
10611 const choiceToAlt = (0,reduce/* default */.Z)(singleTokensTypes, (result, currTokType) => {
10612 if (currTokType !== undefined) {
10613 result[currTokType.tokenTypeIdx] = true;
10614 (0,forEach/* default */.Z)(currTokType.categoryMatches, (currExtendingType) => {
10615 result[currExtendingType] = true;
10616 });
10617 }
10618 return result;
10619 }, {});
10620 return function () {
10621 const nextToken = this.LA(1);
10622 return choiceToAlt[nextToken.tokenTypeIdx] === true;
10623 };
10624 }
10625 }
10626 return function () {
10627 const result = adaptivePredict.call(this, dfas, decisionIndex, EMPTY_PREDICATES, logging);
10628 return typeof result === "object" ? false : result === 0;
10629 };
10630 }
10631 }
10632 function isLL1Sequence(sequences, allowEmpty = true) {
10633 const fullSet = new Set();
10634 for (const alt of sequences) {
10635 const altSet = new Set();
10636 for (const tokType of alt) {
10637 if (tokType === undefined) {
10638 if (allowEmpty) {
10639 // Epsilon production encountered
10640 break;
10641 }
10642 else {
10643 return false;
10644 }
10645 }
10646 const indices = [tokType.tokenTypeIdx].concat(tokType.categoryMatches);
10647 for (const index of indices) {
10648 if (fullSet.has(index)) {
10649 if (!altSet.has(index)) {
10650 return false;
10651 }
10652 }
10653 else {
10654 fullSet.add(index);
10655 altSet.add(index);
10656 }
10657 }
10658 }
10659 }
10660 return true;
10661 }
10662 function initATNSimulator(atn) {
10663 const decisionLength = atn.decisionStates.length;
10664 const decisionToDFA = Array(decisionLength);
10665 for (let i = 0; i < decisionLength; i++) {
10666 decisionToDFA[i] = createDFACache(atn.decisionStates[i], i);
10667 }
10668 return decisionToDFA;
10669 }
10670 function adaptivePredict(dfaCaches, decision, predicateSet, logging) {
10671 const dfa = dfaCaches[decision](predicateSet);
10672 let start = dfa.start;
10673 if (start === undefined) {
10674 const closure = computeStartState(dfa.atnStartState);
10675 start = addDFAState(dfa, newDFAState(closure));
10676 dfa.start = start;
10677 }
10678 const alt = performLookahead.apply(this, [dfa, start, predicateSet, logging]);
10679 return alt;
10680 }
10681 function performLookahead(dfa, s0, predicateSet, logging) {
10682 let previousD = s0;
10683 let i = 1;
10684 const path = [];
10685 let t = this.LA(i++);
10686 while (true) {
10687 let d = getExistingTargetState(previousD, t);
10688 if (d === undefined) {
10689 d = computeLookaheadTarget.apply(this, [dfa, previousD, t, i, predicateSet, logging]);
10690 }
10691 if (d === DFA_ERROR) {
10692 return buildAdaptivePredictError(path, previousD, t);
10693 }
10694 if (d.isAcceptState === true) {
10695 return d.prediction;
10696 }
10697 previousD = d;
10698 path.push(t);
10699 t = this.LA(i++);
10700 }
10701 }
10702 function computeLookaheadTarget(dfa, previousD, token, lookahead, predicateSet, logging) {
10703 const reach = computeReachSet(previousD.configs, token, predicateSet);
10704 if (reach.size === 0) {
10705 addDFAEdge(dfa, previousD, token, DFA_ERROR);
10706 return DFA_ERROR;
10707 }
10708 let newState = newDFAState(reach);
10709 const predictedAlt = getUniqueAlt(reach, predicateSet);
10710 if (predictedAlt !== undefined) {
10711 newState.isAcceptState = true;
10712 newState.prediction = predictedAlt;
10713 newState.configs.uniqueAlt = predictedAlt;
10714 }
10715 else if (hasConflictTerminatingPrediction(reach)) {
10716 const prediction = (0,min/* default */.Z)(reach.alts);
10717 newState.isAcceptState = true;
10718 newState.prediction = prediction;
10719 newState.configs.uniqueAlt = prediction;
10720 reportLookaheadAmbiguity.apply(this, [dfa, lookahead, reach.alts, logging]);
10721 }
10722 newState = addDFAEdge(dfa, previousD, token, newState);
10723 return newState;
10724 }
10725 function reportLookaheadAmbiguity(dfa, lookahead, ambiguityIndices, logging) {
10726 const prefixPath = [];
10727 for (let i = 1; i <= lookahead; i++) {
10728 prefixPath.push(this.LA(i).tokenType);
10729 }
10730 const atnState = dfa.atnStartState;
10731 const topLevelRule = atnState.rule;
10732 const production = atnState.production;
10733 const message = buildAmbiguityError({
10734 topLevelRule,
10735 ambiguityIndices,
10736 production,
10737 prefixPath
10738 });
10739 logging(message);
10740 }
10741 function buildAmbiguityError(options) {
10742 const pathMsg = (0,map/* default */.Z)(options.prefixPath, (currtok) => (0,api/* tokenLabel */.l$)(currtok)).join(", ");
10743 const occurrence = options.production.idx === 0 ? "" : options.production.idx;
10744 let currMessage = `Ambiguous Alternatives Detected: <${options.ambiguityIndices.join(", ")}> in <${getProductionDslName(options.production)}${occurrence}>` +
10745 ` inside <${options.topLevelRule.name}> Rule,\n` +
10746 `<${pathMsg}> may appears as a prefix path in all these alternatives.\n`;
10747 currMessage =
10748 currMessage +
10749 `See: https://chevrotain.io/docs/guide/resolving_grammar_errors.html#AMBIGUOUS_ALTERNATIVES\n` +
10750 `For Further details.`;
10751 return currMessage;
10752 }
10753 function getProductionDslName(prod) {
10754 if (prod instanceof api/* NonTerminal */.Sj) {
10755 return "SUBRULE";
10756 }
10757 else if (prod instanceof api/* Option */.Wx) {
10758 return "OPTION";
10759 }
10760 else if (prod instanceof api/* Alternation */.ue) {
10761 return "OR";
10762 }
10763 else if (prod instanceof api/* RepetitionMandatory */.ej) {
10764 return "AT_LEAST_ONE";
10765 }
10766 else if (prod instanceof api/* RepetitionMandatoryWithSeparator */.fK) {
10767 return "AT_LEAST_ONE_SEP";
10768 }
10769 else if (prod instanceof api/* RepetitionWithSeparator */.pT) {
10770 return "MANY_SEP";
10771 }
10772 else if (prod instanceof api/* Repetition */.hI) {
10773 return "MANY";
10774 }
10775 else if (prod instanceof api/* Terminal */.oI) {
10776 return "CONSUME";
10777 }
10778 else {
10779 throw Error("non exhaustive match");
10780 }
10781 }
10782 function buildAdaptivePredictError(path, previous, current) {
10783 const nextTransitions = (0,flatMap/* default */.Z)(previous.configs.elements, (e) => e.state.transitions);
10784 const nextTokenTypes = lodash_es_uniqBy(nextTransitions
10785 .filter((e) => e instanceof AtomTransition)
10786 .map((e) => e.tokenType), (e) => e.tokenTypeIdx);
10787 return {
10788 actualToken: current,
10789 possibleTokenTypes: nextTokenTypes,
10790 tokenPath: path
10791 };
10792 }
10793 function getExistingTargetState(state, token) {
10794 return state.edges[token.tokenTypeIdx];
10795 }
10796 function computeReachSet(configs, token, predicateSet) {
10797 const intermediate = new ATNConfigSet();
10798 const skippedStopStates = [];
10799 for (const c of configs.elements) {
10800 if (predicateSet.is(c.alt) === false) {
10801 continue;
10802 }
10803 if (c.state.type === ATN_RULE_STOP) {
10804 skippedStopStates.push(c);
10805 continue;
10806 }
10807 const transitionLength = c.state.transitions.length;
10808 for (let i = 0; i < transitionLength; i++) {
10809 const transition = c.state.transitions[i];
10810 const target = getReachableTarget(transition, token);
10811 if (target !== undefined) {
10812 intermediate.add({
10813 state: target,
10814 alt: c.alt,
10815 stack: c.stack
10816 });
10817 }
10818 }
10819 }
10820 let reach;
10821 if (skippedStopStates.length === 0 && intermediate.size === 1) {
10822 reach = intermediate;
10823 }
10824 if (reach === undefined) {
10825 reach = new ATNConfigSet();
10826 for (const c of intermediate.elements) {
10827 closure(c, reach);
10828 }
10829 }
10830 if (skippedStopStates.length > 0 && !hasConfigInRuleStopState(reach)) {
10831 for (const c of skippedStopStates) {
10832 reach.add(c);
10833 }
10834 }
10835 return reach;
10836 }
10837 function getReachableTarget(transition, token) {
10838 if (transition instanceof AtomTransition &&
10839 (0,api/* tokenMatcher */.ol)(token, transition.tokenType)) {
10840 return transition.target;
10841 }
10842 return undefined;
10843 }
10844 function getUniqueAlt(configs, predicateSet) {
10845 let alt;
10846 for (const c of configs.elements) {
10847 if (predicateSet.is(c.alt) === true) {
10848 if (alt === undefined) {
10849 alt = c.alt;
10850 }
10851 else if (alt !== c.alt) {
10852 return undefined;
10853 }
10854 }
10855 }
10856 return alt;
10857 }
10858 function newDFAState(closure) {
10859 return {
10860 configs: closure,
10861 edges: {},
10862 isAcceptState: false,
10863 prediction: -1
10864 };
10865 }
10866 function addDFAEdge(dfa, from, token, to) {
10867 to = addDFAState(dfa, to);
10868 from.edges[token.tokenTypeIdx] = to;
10869 return to;
10870 }
10871 function addDFAState(dfa, state) {
10872 if (state === DFA_ERROR) {
10873 return state;
10874 }
10875 // Repetitions have the same config set
10876 // Therefore, storing the key of the config in a map allows us to create a loop in our DFA
10877 const mapKey = state.configs.key;
10878 const existing = dfa.states[mapKey];
10879 if (existing !== undefined) {
10880 return existing;
10881 }
10882 state.configs.finalize();
10883 dfa.states[mapKey] = state;
10884 return state;
10885 }
10886 function computeStartState(atnState) {
10887 const configs = new ATNConfigSet();
10888 const numberOfTransitions = atnState.transitions.length;
10889 for (let i = 0; i < numberOfTransitions; i++) {
10890 const target = atnState.transitions[i].target;
10891 const config = {
10892 state: target,
10893 alt: i,
10894 stack: []
10895 };
10896 closure(config, configs);
10897 }
10898 return configs;
10899 }
10900 function closure(config, configs) {
10901 const p = config.state;
10902 if (p.type === ATN_RULE_STOP) {
10903 if (config.stack.length > 0) {
10904 const atnStack = [...config.stack];
10905 const followState = atnStack.pop();
10906 const followConfig = {
10907 state: followState,
10908 alt: config.alt,
10909 stack: atnStack
10910 };
10911 closure(followConfig, configs);
10912 }
10913 else {
10914 // Dipping into outer context, simply add the config
10915 // This will stop computation once every config is at the rule stop state
10916 configs.add(config);
10917 }
10918 return;
10919 }
10920 if (!p.epsilonOnlyTransitions) {
10921 configs.add(config);
10922 }
10923 const transitionLength = p.transitions.length;
10924 for (let i = 0; i < transitionLength; i++) {
10925 const transition = p.transitions[i];
10926 const c = getEpsilonTarget(config, transition);
10927 if (c !== undefined) {
10928 closure(c, configs);
10929 }
10930 }
10931 }
10932 function getEpsilonTarget(config, transition) {
10933 if (transition instanceof EpsilonTransition) {
10934 return {
10935 state: transition.target,
10936 alt: config.alt,
10937 stack: config.stack
10938 };
10939 }
10940 else if (transition instanceof RuleTransition) {
10941 const stack = [...config.stack, transition.followState];
10942 return {
10943 state: transition.target,
10944 alt: config.alt,
10945 stack
10946 };
10947 }
10948 return undefined;
10949 }
10950 function hasConfigInRuleStopState(configs) {
10951 for (const c of configs.elements) {
10952 if (c.state.type === ATN_RULE_STOP) {
10953 return true;
10954 }
10955 }
10956 return false;
10957 }
10958 function allConfigsInRuleStopStates(configs) {
10959 for (const c of configs.elements) {
10960 if (c.state.type !== ATN_RULE_STOP) {
10961 return false;
10962 }
10963 }
10964 return true;
10965 }
10966 function hasConflictTerminatingPrediction(configs) {
10967 if (allConfigsInRuleStopStates(configs)) {
10968 return true;
10969 }
10970 const altSets = getConflictingAltSets(configs.elements);
10971 const heuristic = hasConflictingAltSet(altSets) && !hasStateAssociatedWithOneAlt(altSets);
10972 return heuristic;
10973 }
10974 function getConflictingAltSets(configs) {
10975 const configToAlts = new Map();
10976 for (const c of configs) {
10977 const key = getATNConfigKey(c, false);
10978 let alts = configToAlts.get(key);
10979 if (alts === undefined) {
10980 alts = {};
10981 configToAlts.set(key, alts);
10982 }
10983 alts[c.alt] = true;
10984 }
10985 return configToAlts;
10986 }
10987 function hasConflictingAltSet(altSets) {
10988 for (const value of Array.from(altSets.values())) {
10989 if (Object.keys(value).length > 1) {
10990 return true;
10991 }
10992 }
10993 return false;
10994 }
10995 function hasStateAssociatedWithOneAlt(altSets) {
10996 for (const value of Array.from(altSets.values())) {
10997 if (Object.keys(value).length === 1) {
10998 return true;
10999 }
11000 }
11001 return false;
11002 }
11003 //# sourceMappingURL=all-star-lookahead.js.map
11004 ;// CONCATENATED MODULE: ../node_modules/chevrotain-allstar/lib/index.js
11005 /******************************************************************************
11006 * Copyright 2022 TypeFox GmbH
11007 * This program and the accompanying materials are made available under the
11008 * terms of the MIT License, which is available in the project root.
11009 ******************************************************************************/
11010
11011 //# sourceMappingURL=index.js.map
11012 // EXTERNAL MODULE: ../node_modules/langium/lib/utils/ast-utils.js
11013 var ast_utils = __webpack_require__(74857);
11014 ;// CONCATENATED MODULE: ../node_modules/vscode-languageserver-types/lib/esm/main.js
11015 /* --------------------------------------------------------------------------------------------
11016 * Copyright (c) Microsoft Corporation. All rights reserved.
11017 * Licensed under the MIT License. See License.txt in the project root for license information.
11018 * ------------------------------------------------------------------------------------------ */
11019
11020 var DocumentUri;
11021 (function (DocumentUri) {
11022 function is(value) {
11023 return typeof value === 'string';
11024 }
11025 DocumentUri.is = is;
11026 })(DocumentUri || (DocumentUri = {}));
11027 var URI;
11028 (function (URI) {
11029 function is(value) {
11030 return typeof value === 'string';
11031 }
11032 URI.is = is;
11033 })(URI || (URI = {}));
11034 var integer;
11035 (function (integer) {
11036 integer.MIN_VALUE = -2147483648;
11037 integer.MAX_VALUE = 2147483647;
11038 function is(value) {
11039 return typeof value === 'number' && integer.MIN_VALUE <= value && value <= integer.MAX_VALUE;
11040 }
11041 integer.is = is;
11042 })(integer || (integer = {}));
11043 var uinteger;
11044 (function (uinteger) {
11045 uinteger.MIN_VALUE = 0;
11046 uinteger.MAX_VALUE = 2147483647;
11047 function is(value) {
11048 return typeof value === 'number' && uinteger.MIN_VALUE <= value && value <= uinteger.MAX_VALUE;
11049 }
11050 uinteger.is = is;
11051 })(uinteger || (uinteger = {}));
11052 /**
11053 * The Position namespace provides helper functions to work with
11054 * {@link Position} literals.
11055 */
11056 var Position;
11057 (function (Position) {
11058 /**
11059 * Creates a new Position literal from the given line and character.
11060 * @param line The position's line.
11061 * @param character The position's character.
11062 */
11063 function create(line, character) {
11064 if (line === Number.MAX_VALUE) {
11065 line = uinteger.MAX_VALUE;
11066 }
11067 if (character === Number.MAX_VALUE) {
11068 character = uinteger.MAX_VALUE;
11069 }
11070 return { line, character };
11071 }
11072 Position.create = create;
11073 /**
11074 * Checks whether the given literal conforms to the {@link Position} interface.
11075 */
11076 function is(value) {
11077 let candidate = value;
11078 return Is.objectLiteral(candidate) && Is.uinteger(candidate.line) && Is.uinteger(candidate.character);
11079 }
11080 Position.is = is;
11081 })(Position || (Position = {}));
11082 /**
11083 * The Range namespace provides helper functions to work with
11084 * {@link Range} literals.
11085 */
11086 var Range;
11087 (function (Range) {
11088 function create(one, two, three, four) {
11089 if (Is.uinteger(one) && Is.uinteger(two) && Is.uinteger(three) && Is.uinteger(four)) {
11090 return { start: Position.create(one, two), end: Position.create(three, four) };
11091 }
11092 else if (Position.is(one) && Position.is(two)) {
11093 return { start: one, end: two };
11094 }
11095 else {
11096 throw new Error(`Range#create called with invalid arguments[${one}, ${two}, ${three}, ${four}]`);
11097 }
11098 }
11099 Range.create = create;
11100 /**
11101 * Checks whether the given literal conforms to the {@link Range} interface.
11102 */
11103 function is(value) {
11104 let candidate = value;
11105 return Is.objectLiteral(candidate) && Position.is(candidate.start) && Position.is(candidate.end);
11106 }
11107 Range.is = is;
11108 })(Range || (Range = {}));
11109 /**
11110 * The Location namespace provides helper functions to work with
11111 * {@link Location} literals.
11112 */
11113 var Location;
11114 (function (Location) {
11115 /**
11116 * Creates a Location literal.
11117 * @param uri The location's uri.
11118 * @param range The location's range.
11119 */
11120 function create(uri, range) {
11121 return { uri, range };
11122 }
11123 Location.create = create;
11124 /**
11125 * Checks whether the given literal conforms to the {@link Location} interface.
11126 */
11127 function is(value) {
11128 let candidate = value;
11129 return Is.objectLiteral(candidate) && Range.is(candidate.range) && (Is.string(candidate.uri) || Is.undefined(candidate.uri));
11130 }
11131 Location.is = is;
11132 })(Location || (Location = {}));
11133 /**
11134 * The LocationLink namespace provides helper functions to work with
11135 * {@link LocationLink} literals.
11136 */
11137 var LocationLink;
11138 (function (LocationLink) {
11139 /**
11140 * Creates a LocationLink literal.
11141 * @param targetUri The definition's uri.
11142 * @param targetRange The full range of the definition.
11143 * @param targetSelectionRange The span of the symbol definition at the target.
11144 * @param originSelectionRange The span of the symbol being defined in the originating source file.
11145 */
11146 function create(targetUri, targetRange, targetSelectionRange, originSelectionRange) {
11147 return { targetUri, targetRange, targetSelectionRange, originSelectionRange };
11148 }
11149 LocationLink.create = create;
11150 /**
11151 * Checks whether the given literal conforms to the {@link LocationLink} interface.
11152 */
11153 function is(value) {
11154 let candidate = value;
11155 return Is.objectLiteral(candidate) && Range.is(candidate.targetRange) && Is.string(candidate.targetUri)
11156 && Range.is(candidate.targetSelectionRange)
11157 && (Range.is(candidate.originSelectionRange) || Is.undefined(candidate.originSelectionRange));
11158 }
11159 LocationLink.is = is;
11160 })(LocationLink || (LocationLink = {}));
11161 /**
11162 * The Color namespace provides helper functions to work with
11163 * {@link Color} literals.
11164 */
11165 var Color;
11166 (function (Color) {
11167 /**
11168 * Creates a new Color literal.
11169 */
11170 function create(red, green, blue, alpha) {
11171 return {
11172 red,
11173 green,
11174 blue,
11175 alpha,
11176 };
11177 }
11178 Color.create = create;
11179 /**
11180 * Checks whether the given literal conforms to the {@link Color} interface.
11181 */
11182 function is(value) {
11183 const candidate = value;
11184 return Is.objectLiteral(candidate) && Is.numberRange(candidate.red, 0, 1)
11185 && Is.numberRange(candidate.green, 0, 1)
11186 && Is.numberRange(candidate.blue, 0, 1)
11187 && Is.numberRange(candidate.alpha, 0, 1);
11188 }
11189 Color.is = is;
11190 })(Color || (Color = {}));
11191 /**
11192 * The ColorInformation namespace provides helper functions to work with
11193 * {@link ColorInformation} literals.
11194 */
11195 var ColorInformation;
11196 (function (ColorInformation) {
11197 /**
11198 * Creates a new ColorInformation literal.
11199 */
11200 function create(range, color) {
11201 return {
11202 range,
11203 color,
11204 };
11205 }
11206 ColorInformation.create = create;
11207 /**
11208 * Checks whether the given literal conforms to the {@link ColorInformation} interface.
11209 */
11210 function is(value) {
11211 const candidate = value;
11212 return Is.objectLiteral(candidate) && Range.is(candidate.range) && Color.is(candidate.color);
11213 }
11214 ColorInformation.is = is;
11215 })(ColorInformation || (ColorInformation = {}));
11216 /**
11217 * The Color namespace provides helper functions to work with
11218 * {@link ColorPresentation} literals.
11219 */
11220 var ColorPresentation;
11221 (function (ColorPresentation) {
11222 /**
11223 * Creates a new ColorInformation literal.
11224 */
11225 function create(label, textEdit, additionalTextEdits) {
11226 return {
11227 label,
11228 textEdit,
11229 additionalTextEdits,
11230 };
11231 }
11232 ColorPresentation.create = create;
11233 /**
11234 * Checks whether the given literal conforms to the {@link ColorInformation} interface.
11235 */
11236 function is(value) {
11237 const candidate = value;
11238 return Is.objectLiteral(candidate) && Is.string(candidate.label)
11239 && (Is.undefined(candidate.textEdit) || TextEdit.is(candidate))
11240 && (Is.undefined(candidate.additionalTextEdits) || Is.typedArray(candidate.additionalTextEdits, TextEdit.is));
11241 }
11242 ColorPresentation.is = is;
11243 })(ColorPresentation || (ColorPresentation = {}));
11244 /**
11245 * A set of predefined range kinds.
11246 */
11247 var FoldingRangeKind;
11248 (function (FoldingRangeKind) {
11249 /**
11250 * Folding range for a comment
11251 */
11252 FoldingRangeKind.Comment = 'comment';
11253 /**
11254 * Folding range for an import or include
11255 */
11256 FoldingRangeKind.Imports = 'imports';
11257 /**
11258 * Folding range for a region (e.g. `#region`)
11259 */
11260 FoldingRangeKind.Region = 'region';
11261 })(FoldingRangeKind || (FoldingRangeKind = {}));
11262 /**
11263 * The folding range namespace provides helper functions to work with
11264 * {@link FoldingRange} literals.
11265 */
11266 var FoldingRange;
11267 (function (FoldingRange) {
11268 /**
11269 * Creates a new FoldingRange literal.
11270 */
11271 function create(startLine, endLine, startCharacter, endCharacter, kind, collapsedText) {
11272 const result = {
11273 startLine,
11274 endLine
11275 };
11276 if (Is.defined(startCharacter)) {
11277 result.startCharacter = startCharacter;
11278 }
11279 if (Is.defined(endCharacter)) {
11280 result.endCharacter = endCharacter;
11281 }
11282 if (Is.defined(kind)) {
11283 result.kind = kind;
11284 }
11285 if (Is.defined(collapsedText)) {
11286 result.collapsedText = collapsedText;
11287 }
11288 return result;
11289 }
11290 FoldingRange.create = create;
11291 /**
11292 * Checks whether the given literal conforms to the {@link FoldingRange} interface.
11293 */
11294 function is(value) {
11295 const candidate = value;
11296 return Is.objectLiteral(candidate) && Is.uinteger(candidate.startLine) && Is.uinteger(candidate.startLine)
11297 && (Is.undefined(candidate.startCharacter) || Is.uinteger(candidate.startCharacter))
11298 && (Is.undefined(candidate.endCharacter) || Is.uinteger(candidate.endCharacter))
11299 && (Is.undefined(candidate.kind) || Is.string(candidate.kind));
11300 }
11301 FoldingRange.is = is;
11302 })(FoldingRange || (FoldingRange = {}));
11303 /**
11304 * The DiagnosticRelatedInformation namespace provides helper functions to work with
11305 * {@link DiagnosticRelatedInformation} literals.
11306 */
11307 var DiagnosticRelatedInformation;
11308 (function (DiagnosticRelatedInformation) {
11309 /**
11310 * Creates a new DiagnosticRelatedInformation literal.
11311 */
11312 function create(location, message) {
11313 return {
11314 location,
11315 message
11316 };
11317 }
11318 DiagnosticRelatedInformation.create = create;
11319 /**
11320 * Checks whether the given literal conforms to the {@link DiagnosticRelatedInformation} interface.
11321 */
11322 function is(value) {
11323 let candidate = value;
11324 return Is.defined(candidate) && Location.is(candidate.location) && Is.string(candidate.message);
11325 }
11326 DiagnosticRelatedInformation.is = is;
11327 })(DiagnosticRelatedInformation || (DiagnosticRelatedInformation = {}));
11328 /**
11329 * The diagnostic's severity.
11330 */
11331 var DiagnosticSeverity;
11332 (function (DiagnosticSeverity) {
11333 /**
11334 * Reports an error.
11335 */
11336 DiagnosticSeverity.Error = 1;
11337 /**
11338 * Reports a warning.
11339 */
11340 DiagnosticSeverity.Warning = 2;
11341 /**
11342 * Reports an information.
11343 */
11344 DiagnosticSeverity.Information = 3;
11345 /**
11346 * Reports a hint.
11347 */
11348 DiagnosticSeverity.Hint = 4;
11349 })(DiagnosticSeverity || (DiagnosticSeverity = {}));
11350 /**
11351 * The diagnostic tags.
11352 *
11353 * @since 3.15.0
11354 */
11355 var DiagnosticTag;
11356 (function (DiagnosticTag) {
11357 /**
11358 * Unused or unnecessary code.
11359 *
11360 * Clients are allowed to render diagnostics with this tag faded out instead of having
11361 * an error squiggle.
11362 */
11363 DiagnosticTag.Unnecessary = 1;
11364 /**
11365 * Deprecated or obsolete code.
11366 *
11367 * Clients are allowed to rendered diagnostics with this tag strike through.
11368 */
11369 DiagnosticTag.Deprecated = 2;
11370 })(DiagnosticTag || (DiagnosticTag = {}));
11371 /**
11372 * The CodeDescription namespace provides functions to deal with descriptions for diagnostic codes.
11373 *
11374 * @since 3.16.0
11375 */
11376 var CodeDescription;
11377 (function (CodeDescription) {
11378 function is(value) {
11379 const candidate = value;
11380 return Is.objectLiteral(candidate) && Is.string(candidate.href);
11381 }
11382 CodeDescription.is = is;
11383 })(CodeDescription || (CodeDescription = {}));
11384 /**
11385 * The Diagnostic namespace provides helper functions to work with
11386 * {@link Diagnostic} literals.
11387 */
11388 var Diagnostic;
11389 (function (Diagnostic) {
11390 /**
11391 * Creates a new Diagnostic literal.
11392 */
11393 function create(range, message, severity, code, source, relatedInformation) {
11394 let result = { range, message };
11395 if (Is.defined(severity)) {
11396 result.severity = severity;
11397 }
11398 if (Is.defined(code)) {
11399 result.code = code;
11400 }
11401 if (Is.defined(source)) {
11402 result.source = source;
11403 }
11404 if (Is.defined(relatedInformation)) {
11405 result.relatedInformation = relatedInformation;
11406 }
11407 return result;
11408 }
11409 Diagnostic.create = create;
11410 /**
11411 * Checks whether the given literal conforms to the {@link Diagnostic} interface.
11412 */
11413 function is(value) {
11414 var _a;
11415 let candidate = value;
11416 return Is.defined(candidate)
11417 && Range.is(candidate.range)
11418 && Is.string(candidate.message)
11419 && (Is.number(candidate.severity) || Is.undefined(candidate.severity))
11420 && (Is.integer(candidate.code) || Is.string(candidate.code) || Is.undefined(candidate.code))
11421 && (Is.undefined(candidate.codeDescription) || (Is.string((_a = candidate.codeDescription) === null || _a === void 0 ? void 0 : _a.href)))
11422 && (Is.string(candidate.source) || Is.undefined(candidate.source))
11423 && (Is.undefined(candidate.relatedInformation) || Is.typedArray(candidate.relatedInformation, DiagnosticRelatedInformation.is));
11424 }
11425 Diagnostic.is = is;
11426 })(Diagnostic || (Diagnostic = {}));
11427 /**
11428 * The Command namespace provides helper functions to work with
11429 * {@link Command} literals.
11430 */
11431 var Command;
11432 (function (Command) {
11433 /**
11434 * Creates a new Command literal.
11435 */
11436 function create(title, command, ...args) {
11437 let result = { title, command };
11438 if (Is.defined(args) && args.length > 0) {
11439 result.arguments = args;
11440 }
11441 return result;
11442 }
11443 Command.create = create;
11444 /**
11445 * Checks whether the given literal conforms to the {@link Command} interface.
11446 */
11447 function is(value) {
11448 let candidate = value;
11449 return Is.defined(candidate) && Is.string(candidate.title) && Is.string(candidate.command);
11450 }
11451 Command.is = is;
11452 })(Command || (Command = {}));
11453 /**
11454 * The TextEdit namespace provides helper function to create replace,
11455 * insert and delete edits more easily.
11456 */
11457 var TextEdit;
11458 (function (TextEdit) {
11459 /**
11460 * Creates a replace text edit.
11461 * @param range The range of text to be replaced.
11462 * @param newText The new text.
11463 */
11464 function replace(range, newText) {
11465 return { range, newText };
11466 }
11467 TextEdit.replace = replace;
11468 /**
11469 * Creates an insert text edit.
11470 * @param position The position to insert the text at.
11471 * @param newText The text to be inserted.
11472 */
11473 function insert(position, newText) {
11474 return { range: { start: position, end: position }, newText };
11475 }
11476 TextEdit.insert = insert;
11477 /**
11478 * Creates a delete text edit.
11479 * @param range The range of text to be deleted.
11480 */
11481 function del(range) {
11482 return { range, newText: '' };
11483 }
11484 TextEdit.del = del;
11485 function is(value) {
11486 const candidate = value;
11487 return Is.objectLiteral(candidate)
11488 && Is.string(candidate.newText)
11489 && Range.is(candidate.range);
11490 }
11491 TextEdit.is = is;
11492 })(TextEdit || (TextEdit = {}));
11493 var ChangeAnnotation;
11494 (function (ChangeAnnotation) {
11495 function create(label, needsConfirmation, description) {
11496 const result = { label };
11497 if (needsConfirmation !== undefined) {
11498 result.needsConfirmation = needsConfirmation;
11499 }
11500 if (description !== undefined) {
11501 result.description = description;
11502 }
11503 return result;
11504 }
11505 ChangeAnnotation.create = create;
11506 function is(value) {
11507 const candidate = value;
11508 return Is.objectLiteral(candidate) && Is.string(candidate.label) &&
11509 (Is.boolean(candidate.needsConfirmation) || candidate.needsConfirmation === undefined) &&
11510 (Is.string(candidate.description) || candidate.description === undefined);
11511 }
11512 ChangeAnnotation.is = is;
11513 })(ChangeAnnotation || (ChangeAnnotation = {}));
11514 var ChangeAnnotationIdentifier;
11515 (function (ChangeAnnotationIdentifier) {
11516 function is(value) {
11517 const candidate = value;
11518 return Is.string(candidate);
11519 }
11520 ChangeAnnotationIdentifier.is = is;
11521 })(ChangeAnnotationIdentifier || (ChangeAnnotationIdentifier = {}));
11522 var AnnotatedTextEdit;
11523 (function (AnnotatedTextEdit) {
11524 /**
11525 * Creates an annotated replace text edit.
11526 *
11527 * @param range The range of text to be replaced.
11528 * @param newText The new text.
11529 * @param annotation The annotation.
11530 */
11531 function replace(range, newText, annotation) {
11532 return { range, newText, annotationId: annotation };
11533 }
11534 AnnotatedTextEdit.replace = replace;
11535 /**
11536 * Creates an annotated insert text edit.
11537 *
11538 * @param position The position to insert the text at.
11539 * @param newText The text to be inserted.
11540 * @param annotation The annotation.
11541 */
11542 function insert(position, newText, annotation) {
11543 return { range: { start: position, end: position }, newText, annotationId: annotation };
11544 }
11545 AnnotatedTextEdit.insert = insert;
11546 /**
11547 * Creates an annotated delete text edit.
11548 *
11549 * @param range The range of text to be deleted.
11550 * @param annotation The annotation.
11551 */
11552 function del(range, annotation) {
11553 return { range, newText: '', annotationId: annotation };
11554 }
11555 AnnotatedTextEdit.del = del;
11556 function is(value) {
11557 const candidate = value;
11558 return TextEdit.is(candidate) && (ChangeAnnotation.is(candidate.annotationId) || ChangeAnnotationIdentifier.is(candidate.annotationId));
11559 }
11560 AnnotatedTextEdit.is = is;
11561 })(AnnotatedTextEdit || (AnnotatedTextEdit = {}));
11562 /**
11563 * The TextDocumentEdit namespace provides helper function to create
11564 * an edit that manipulates a text document.
11565 */
11566 var TextDocumentEdit;
11567 (function (TextDocumentEdit) {
11568 /**
11569 * Creates a new `TextDocumentEdit`
11570 */
11571 function create(textDocument, edits) {
11572 return { textDocument, edits };
11573 }
11574 TextDocumentEdit.create = create;
11575 function is(value) {
11576 let candidate = value;
11577 return Is.defined(candidate)
11578 && OptionalVersionedTextDocumentIdentifier.is(candidate.textDocument)
11579 && Array.isArray(candidate.edits);
11580 }
11581 TextDocumentEdit.is = is;
11582 })(TextDocumentEdit || (TextDocumentEdit = {}));
11583 var CreateFile;
11584 (function (CreateFile) {
11585 function create(uri, options, annotation) {
11586 let result = {
11587 kind: 'create',
11588 uri
11589 };
11590 if (options !== undefined && (options.overwrite !== undefined || options.ignoreIfExists !== undefined)) {
11591 result.options = options;
11592 }
11593 if (annotation !== undefined) {
11594 result.annotationId = annotation;
11595 }
11596 return result;
11597 }
11598 CreateFile.create = create;
11599 function is(value) {
11600 let candidate = value;
11601 return candidate && candidate.kind === 'create' && Is.string(candidate.uri) && (candidate.options === undefined ||
11602 ((candidate.options.overwrite === undefined || Is.boolean(candidate.options.overwrite)) && (candidate.options.ignoreIfExists === undefined || Is.boolean(candidate.options.ignoreIfExists)))) && (candidate.annotationId === undefined || ChangeAnnotationIdentifier.is(candidate.annotationId));
11603 }
11604 CreateFile.is = is;
11605 })(CreateFile || (CreateFile = {}));
11606 var RenameFile;
11607 (function (RenameFile) {
11608 function create(oldUri, newUri, options, annotation) {
11609 let result = {
11610 kind: 'rename',
11611 oldUri,
11612 newUri
11613 };
11614 if (options !== undefined && (options.overwrite !== undefined || options.ignoreIfExists !== undefined)) {
11615 result.options = options;
11616 }
11617 if (annotation !== undefined) {
11618 result.annotationId = annotation;
11619 }
11620 return result;
11621 }
11622 RenameFile.create = create;
11623 function is(value) {
11624 let candidate = value;
11625 return candidate && candidate.kind === 'rename' && Is.string(candidate.oldUri) && Is.string(candidate.newUri) && (candidate.options === undefined ||
11626 ((candidate.options.overwrite === undefined || Is.boolean(candidate.options.overwrite)) && (candidate.options.ignoreIfExists === undefined || Is.boolean(candidate.options.ignoreIfExists)))) && (candidate.annotationId === undefined || ChangeAnnotationIdentifier.is(candidate.annotationId));
11627 }
11628 RenameFile.is = is;
11629 })(RenameFile || (RenameFile = {}));
11630 var DeleteFile;
11631 (function (DeleteFile) {
11632 function create(uri, options, annotation) {
11633 let result = {
11634 kind: 'delete',
11635 uri
11636 };
11637 if (options !== undefined && (options.recursive !== undefined || options.ignoreIfNotExists !== undefined)) {
11638 result.options = options;
11639 }
11640 if (annotation !== undefined) {
11641 result.annotationId = annotation;
11642 }
11643 return result;
11644 }
11645 DeleteFile.create = create;
11646 function is(value) {
11647 let candidate = value;
11648 return candidate && candidate.kind === 'delete' && Is.string(candidate.uri) && (candidate.options === undefined ||
11649 ((candidate.options.recursive === undefined || Is.boolean(candidate.options.recursive)) && (candidate.options.ignoreIfNotExists === undefined || Is.boolean(candidate.options.ignoreIfNotExists)))) && (candidate.annotationId === undefined || ChangeAnnotationIdentifier.is(candidate.annotationId));
11650 }
11651 DeleteFile.is = is;
11652 })(DeleteFile || (DeleteFile = {}));
11653 var WorkspaceEdit;
11654 (function (WorkspaceEdit) {
11655 function is(value) {
11656 let candidate = value;
11657 return candidate &&
11658 (candidate.changes !== undefined || candidate.documentChanges !== undefined) &&
11659 (candidate.documentChanges === undefined || candidate.documentChanges.every((change) => {
11660 if (Is.string(change.kind)) {
11661 return CreateFile.is(change) || RenameFile.is(change) || DeleteFile.is(change);
11662 }
11663 else {
11664 return TextDocumentEdit.is(change);
11665 }
11666 }));
11667 }
11668 WorkspaceEdit.is = is;
11669 })(WorkspaceEdit || (WorkspaceEdit = {}));
11670 class TextEditChangeImpl {
11671 constructor(edits, changeAnnotations) {
11672 this.edits = edits;
11673 this.changeAnnotations = changeAnnotations;
11674 }
11675 insert(position, newText, annotation) {
11676 let edit;
11677 let id;
11678 if (annotation === undefined) {
11679 edit = TextEdit.insert(position, newText);
11680 }
11681 else if (ChangeAnnotationIdentifier.is(annotation)) {
11682 id = annotation;
11683 edit = AnnotatedTextEdit.insert(position, newText, annotation);
11684 }
11685 else {
11686 this.assertChangeAnnotations(this.changeAnnotations);
11687 id = this.changeAnnotations.manage(annotation);
11688 edit = AnnotatedTextEdit.insert(position, newText, id);
11689 }
11690 this.edits.push(edit);
11691 if (id !== undefined) {
11692 return id;
11693 }
11694 }
11695 replace(range, newText, annotation) {
11696 let edit;
11697 let id;
11698 if (annotation === undefined) {
11699 edit = TextEdit.replace(range, newText);
11700 }
11701 else if (ChangeAnnotationIdentifier.is(annotation)) {
11702 id = annotation;
11703 edit = AnnotatedTextEdit.replace(range, newText, annotation);
11704 }
11705 else {
11706 this.assertChangeAnnotations(this.changeAnnotations);
11707 id = this.changeAnnotations.manage(annotation);
11708 edit = AnnotatedTextEdit.replace(range, newText, id);
11709 }
11710 this.edits.push(edit);
11711 if (id !== undefined) {
11712 return id;
11713 }
11714 }
11715 delete(range, annotation) {
11716 let edit;
11717 let id;
11718 if (annotation === undefined) {
11719 edit = TextEdit.del(range);
11720 }
11721 else if (ChangeAnnotationIdentifier.is(annotation)) {
11722 id = annotation;
11723 edit = AnnotatedTextEdit.del(range, annotation);
11724 }
11725 else {
11726 this.assertChangeAnnotations(this.changeAnnotations);
11727 id = this.changeAnnotations.manage(annotation);
11728 edit = AnnotatedTextEdit.del(range, id);
11729 }
11730 this.edits.push(edit);
11731 if (id !== undefined) {
11732 return id;
11733 }
11734 }
11735 add(edit) {
11736 this.edits.push(edit);
11737 }
11738 all() {
11739 return this.edits;
11740 }
11741 clear() {
11742 this.edits.splice(0, this.edits.length);
11743 }
11744 assertChangeAnnotations(value) {
11745 if (value === undefined) {
11746 throw new Error(`Text edit change is not configured to manage change annotations.`);
11747 }
11748 }
11749 }
11750 /**
11751 * A helper class
11752 */
11753 class ChangeAnnotations {
11754 constructor(annotations) {
11755 this._annotations = annotations === undefined ? Object.create(null) : annotations;
11756 this._counter = 0;
11757 this._size = 0;
11758 }
11759 all() {
11760 return this._annotations;
11761 }
11762 get size() {
11763 return this._size;
11764 }
11765 manage(idOrAnnotation, annotation) {
11766 let id;
11767 if (ChangeAnnotationIdentifier.is(idOrAnnotation)) {
11768 id = idOrAnnotation;
11769 }
11770 else {
11771 id = this.nextId();
11772 annotation = idOrAnnotation;
11773 }
11774 if (this._annotations[id] !== undefined) {
11775 throw new Error(`Id ${id} is already in use.`);
11776 }
11777 if (annotation === undefined) {
11778 throw new Error(`No annotation provided for id ${id}`);
11779 }
11780 this._annotations[id] = annotation;
11781 this._size++;
11782 return id;
11783 }
11784 nextId() {
11785 this._counter++;
11786 return this._counter.toString();
11787 }
11788 }
11789 /**
11790 * A workspace change helps constructing changes to a workspace.
11791 */
11792 class WorkspaceChange {
11793 constructor(workspaceEdit) {
11794 this._textEditChanges = Object.create(null);
11795 if (workspaceEdit !== undefined) {
11796 this._workspaceEdit = workspaceEdit;
11797 if (workspaceEdit.documentChanges) {
11798 this._changeAnnotations = new ChangeAnnotations(workspaceEdit.changeAnnotations);
11799 workspaceEdit.changeAnnotations = this._changeAnnotations.all();
11800 workspaceEdit.documentChanges.forEach((change) => {
11801 if (TextDocumentEdit.is(change)) {
11802 const textEditChange = new TextEditChangeImpl(change.edits, this._changeAnnotations);
11803 this._textEditChanges[change.textDocument.uri] = textEditChange;
11804 }
11805 });
11806 }
11807 else if (workspaceEdit.changes) {
11808 Object.keys(workspaceEdit.changes).forEach((key) => {
11809 const textEditChange = new TextEditChangeImpl(workspaceEdit.changes[key]);
11810 this._textEditChanges[key] = textEditChange;
11811 });
11812 }
11813 }
11814 else {
11815 this._workspaceEdit = {};
11816 }
11817 }
11818 /**
11819 * Returns the underlying {@link WorkspaceEdit} literal
11820 * use to be returned from a workspace edit operation like rename.
11821 */
11822 get edit() {
11823 this.initDocumentChanges();
11824 if (this._changeAnnotations !== undefined) {
11825 if (this._changeAnnotations.size === 0) {
11826 this._workspaceEdit.changeAnnotations = undefined;
11827 }
11828 else {
11829 this._workspaceEdit.changeAnnotations = this._changeAnnotations.all();
11830 }
11831 }
11832 return this._workspaceEdit;
11833 }
11834 getTextEditChange(key) {
11835 if (OptionalVersionedTextDocumentIdentifier.is(key)) {
11836 this.initDocumentChanges();
11837 if (this._workspaceEdit.documentChanges === undefined) {
11838 throw new Error('Workspace edit is not configured for document changes.');
11839 }
11840 const textDocument = { uri: key.uri, version: key.version };
11841 let result = this._textEditChanges[textDocument.uri];
11842 if (!result) {
11843 const edits = [];
11844 const textDocumentEdit = {
11845 textDocument,
11846 edits
11847 };
11848 this._workspaceEdit.documentChanges.push(textDocumentEdit);
11849 result = new TextEditChangeImpl(edits, this._changeAnnotations);
11850 this._textEditChanges[textDocument.uri] = result;
11851 }
11852 return result;
11853 }
11854 else {
11855 this.initChanges();
11856 if (this._workspaceEdit.changes === undefined) {
11857 throw new Error('Workspace edit is not configured for normal text edit changes.');
11858 }
11859 let result = this._textEditChanges[key];
11860 if (!result) {
11861 let edits = [];
11862 this._workspaceEdit.changes[key] = edits;
11863 result = new TextEditChangeImpl(edits);
11864 this._textEditChanges[key] = result;
11865 }
11866 return result;
11867 }
11868 }
11869 initDocumentChanges() {
11870 if (this._workspaceEdit.documentChanges === undefined && this._workspaceEdit.changes === undefined) {
11871 this._changeAnnotations = new ChangeAnnotations();
11872 this._workspaceEdit.documentChanges = [];
11873 this._workspaceEdit.changeAnnotations = this._changeAnnotations.all();
11874 }
11875 }
11876 initChanges() {
11877 if (this._workspaceEdit.documentChanges === undefined && this._workspaceEdit.changes === undefined) {
11878 this._workspaceEdit.changes = Object.create(null);
11879 }
11880 }
11881 createFile(uri, optionsOrAnnotation, options) {
11882 this.initDocumentChanges();
11883 if (this._workspaceEdit.documentChanges === undefined) {
11884 throw new Error('Workspace edit is not configured for document changes.');
11885 }
11886 let annotation;
11887 if (ChangeAnnotation.is(optionsOrAnnotation) || ChangeAnnotationIdentifier.is(optionsOrAnnotation)) {
11888 annotation = optionsOrAnnotation;
11889 }
11890 else {
11891 options = optionsOrAnnotation;
11892 }
11893 let operation;
11894 let id;
11895 if (annotation === undefined) {
11896 operation = CreateFile.create(uri, options);
11897 }
11898 else {
11899 id = ChangeAnnotationIdentifier.is(annotation) ? annotation : this._changeAnnotations.manage(annotation);
11900 operation = CreateFile.create(uri, options, id);
11901 }
11902 this._workspaceEdit.documentChanges.push(operation);
11903 if (id !== undefined) {
11904 return id;
11905 }
11906 }
11907 renameFile(oldUri, newUri, optionsOrAnnotation, options) {
11908 this.initDocumentChanges();
11909 if (this._workspaceEdit.documentChanges === undefined) {
11910 throw new Error('Workspace edit is not configured for document changes.');
11911 }
11912 let annotation;
11913 if (ChangeAnnotation.is(optionsOrAnnotation) || ChangeAnnotationIdentifier.is(optionsOrAnnotation)) {
11914 annotation = optionsOrAnnotation;
11915 }
11916 else {
11917 options = optionsOrAnnotation;
11918 }
11919 let operation;
11920 let id;
11921 if (annotation === undefined) {
11922 operation = RenameFile.create(oldUri, newUri, options);
11923 }
11924 else {
11925 id = ChangeAnnotationIdentifier.is(annotation) ? annotation : this._changeAnnotations.manage(annotation);
11926 operation = RenameFile.create(oldUri, newUri, options, id);
11927 }
11928 this._workspaceEdit.documentChanges.push(operation);
11929 if (id !== undefined) {
11930 return id;
11931 }
11932 }
11933 deleteFile(uri, optionsOrAnnotation, options) {
11934 this.initDocumentChanges();
11935 if (this._workspaceEdit.documentChanges === undefined) {
11936 throw new Error('Workspace edit is not configured for document changes.');
11937 }
11938 let annotation;
11939 if (ChangeAnnotation.is(optionsOrAnnotation) || ChangeAnnotationIdentifier.is(optionsOrAnnotation)) {
11940 annotation = optionsOrAnnotation;
11941 }
11942 else {
11943 options = optionsOrAnnotation;
11944 }
11945 let operation;
11946 let id;
11947 if (annotation === undefined) {
11948 operation = DeleteFile.create(uri, options);
11949 }
11950 else {
11951 id = ChangeAnnotationIdentifier.is(annotation) ? annotation : this._changeAnnotations.manage(annotation);
11952 operation = DeleteFile.create(uri, options, id);
11953 }
11954 this._workspaceEdit.documentChanges.push(operation);
11955 if (id !== undefined) {
11956 return id;
11957 }
11958 }
11959 }
11960 /**
11961 * The TextDocumentIdentifier namespace provides helper functions to work with
11962 * {@link TextDocumentIdentifier} literals.
11963 */
11964 var TextDocumentIdentifier;
11965 (function (TextDocumentIdentifier) {
11966 /**
11967 * Creates a new TextDocumentIdentifier literal.
11968 * @param uri The document's uri.
11969 */
11970 function create(uri) {
11971 return { uri };
11972 }
11973 TextDocumentIdentifier.create = create;
11974 /**
11975 * Checks whether the given literal conforms to the {@link TextDocumentIdentifier} interface.
11976 */
11977 function is(value) {
11978 let candidate = value;
11979 return Is.defined(candidate) && Is.string(candidate.uri);
11980 }
11981 TextDocumentIdentifier.is = is;
11982 })(TextDocumentIdentifier || (TextDocumentIdentifier = {}));
11983 /**
11984 * The VersionedTextDocumentIdentifier namespace provides helper functions to work with
11985 * {@link VersionedTextDocumentIdentifier} literals.
11986 */
11987 var VersionedTextDocumentIdentifier;
11988 (function (VersionedTextDocumentIdentifier) {
11989 /**
11990 * Creates a new VersionedTextDocumentIdentifier literal.
11991 * @param uri The document's uri.
11992 * @param version The document's version.
11993 */
11994 function create(uri, version) {
11995 return { uri, version };
11996 }
11997 VersionedTextDocumentIdentifier.create = create;
11998 /**
11999 * Checks whether the given literal conforms to the {@link VersionedTextDocumentIdentifier} interface.
12000 */
12001 function is(value) {
12002 let candidate = value;
12003 return Is.defined(candidate) && Is.string(candidate.uri) && Is.integer(candidate.version);
12004 }
12005 VersionedTextDocumentIdentifier.is = is;
12006 })(VersionedTextDocumentIdentifier || (VersionedTextDocumentIdentifier = {}));
12007 /**
12008 * The OptionalVersionedTextDocumentIdentifier namespace provides helper functions to work with
12009 * {@link OptionalVersionedTextDocumentIdentifier} literals.
12010 */
12011 var OptionalVersionedTextDocumentIdentifier;
12012 (function (OptionalVersionedTextDocumentIdentifier) {
12013 /**
12014 * Creates a new OptionalVersionedTextDocumentIdentifier literal.
12015 * @param uri The document's uri.
12016 * @param version The document's version.
12017 */
12018 function create(uri, version) {
12019 return { uri, version };
12020 }
12021 OptionalVersionedTextDocumentIdentifier.create = create;
12022 /**
12023 * Checks whether the given literal conforms to the {@link OptionalVersionedTextDocumentIdentifier} interface.
12024 */
12025 function is(value) {
12026 let candidate = value;
12027 return Is.defined(candidate) && Is.string(candidate.uri) && (candidate.version === null || Is.integer(candidate.version));
12028 }
12029 OptionalVersionedTextDocumentIdentifier.is = is;
12030 })(OptionalVersionedTextDocumentIdentifier || (OptionalVersionedTextDocumentIdentifier = {}));
12031 /**
12032 * The TextDocumentItem namespace provides helper functions to work with
12033 * {@link TextDocumentItem} literals.
12034 */
12035 var TextDocumentItem;
12036 (function (TextDocumentItem) {
12037 /**
12038 * Creates a new TextDocumentItem literal.
12039 * @param uri The document's uri.
12040 * @param languageId The document's language identifier.
12041 * @param version The document's version number.
12042 * @param text The document's text.
12043 */
12044 function create(uri, languageId, version, text) {
12045 return { uri, languageId, version, text };
12046 }
12047 TextDocumentItem.create = create;
12048 /**
12049 * Checks whether the given literal conforms to the {@link TextDocumentItem} interface.
12050 */
12051 function is(value) {
12052 let candidate = value;
12053 return Is.defined(candidate) && Is.string(candidate.uri) && Is.string(candidate.languageId) && Is.integer(candidate.version) && Is.string(candidate.text);
12054 }
12055 TextDocumentItem.is = is;
12056 })(TextDocumentItem || (TextDocumentItem = {}));
12057 /**
12058 * Describes the content type that a client supports in various
12059 * result literals like `Hover`, `ParameterInfo` or `CompletionItem`.
12060 *
12061 * Please note that `MarkupKinds` must not start with a `$`. This kinds
12062 * are reserved for internal usage.
12063 */
12064 var MarkupKind;
12065 (function (MarkupKind) {
12066 /**
12067 * Plain text is supported as a content format
12068 */
12069 MarkupKind.PlainText = 'plaintext';
12070 /**
12071 * Markdown is supported as a content format
12072 */
12073 MarkupKind.Markdown = 'markdown';
12074 /**
12075 * Checks whether the given value is a value of the {@link MarkupKind} type.
12076 */
12077 function is(value) {
12078 const candidate = value;
12079 return candidate === MarkupKind.PlainText || candidate === MarkupKind.Markdown;
12080 }
12081 MarkupKind.is = is;
12082 })(MarkupKind || (MarkupKind = {}));
12083 var MarkupContent;
12084 (function (MarkupContent) {
12085 /**
12086 * Checks whether the given value conforms to the {@link MarkupContent} interface.
12087 */
12088 function is(value) {
12089 const candidate = value;
12090 return Is.objectLiteral(value) && MarkupKind.is(candidate.kind) && Is.string(candidate.value);
12091 }
12092 MarkupContent.is = is;
12093 })(MarkupContent || (MarkupContent = {}));
12094 /**
12095 * The kind of a completion entry.
12096 */
12097 var CompletionItemKind;
12098 (function (CompletionItemKind) {
12099 CompletionItemKind.Text = 1;
12100 CompletionItemKind.Method = 2;
12101 CompletionItemKind.Function = 3;
12102 CompletionItemKind.Constructor = 4;
12103 CompletionItemKind.Field = 5;
12104 CompletionItemKind.Variable = 6;
12105 CompletionItemKind.Class = 7;
12106 CompletionItemKind.Interface = 8;
12107 CompletionItemKind.Module = 9;
12108 CompletionItemKind.Property = 10;
12109 CompletionItemKind.Unit = 11;
12110 CompletionItemKind.Value = 12;
12111 CompletionItemKind.Enum = 13;
12112 CompletionItemKind.Keyword = 14;
12113 CompletionItemKind.Snippet = 15;
12114 CompletionItemKind.Color = 16;
12115 CompletionItemKind.File = 17;
12116 CompletionItemKind.Reference = 18;
12117 CompletionItemKind.Folder = 19;
12118 CompletionItemKind.EnumMember = 20;
12119 CompletionItemKind.Constant = 21;
12120 CompletionItemKind.Struct = 22;
12121 CompletionItemKind.Event = 23;
12122 CompletionItemKind.Operator = 24;
12123 CompletionItemKind.TypeParameter = 25;
12124 })(CompletionItemKind || (CompletionItemKind = {}));
12125 /**
12126 * Defines whether the insert text in a completion item should be interpreted as
12127 * plain text or a snippet.
12128 */
12129 var InsertTextFormat;
12130 (function (InsertTextFormat) {
12131 /**
12132 * The primary text to be inserted is treated as a plain string.
12133 */
12134 InsertTextFormat.PlainText = 1;
12135 /**
12136 * The primary text to be inserted is treated as a snippet.
12137 *
12138 * A snippet can define tab stops and placeholders with `$1`, `$2`
12139 * and `${3:foo}`. `$0` defines the final tab stop, it defaults to
12140 * the end of the snippet. Placeholders with equal identifiers are linked,
12141 * that is typing in one will update others too.
12142 *
12143 * See also: https://microsoft.github.io/language-server-protocol/specifications/specification-current/#snippet_syntax
12144 */
12145 InsertTextFormat.Snippet = 2;
12146 })(InsertTextFormat || (InsertTextFormat = {}));
12147 /**
12148 * Completion item tags are extra annotations that tweak the rendering of a completion
12149 * item.
12150 *
12151 * @since 3.15.0
12152 */
12153 var CompletionItemTag;
12154 (function (CompletionItemTag) {
12155 /**
12156 * Render a completion as obsolete, usually using a strike-out.
12157 */
12158 CompletionItemTag.Deprecated = 1;
12159 })(CompletionItemTag || (CompletionItemTag = {}));
12160 /**
12161 * The InsertReplaceEdit namespace provides functions to deal with insert / replace edits.
12162 *
12163 * @since 3.16.0
12164 */
12165 var InsertReplaceEdit;
12166 (function (InsertReplaceEdit) {
12167 /**
12168 * Creates a new insert / replace edit
12169 */
12170 function create(newText, insert, replace) {
12171 return { newText, insert, replace };
12172 }
12173 InsertReplaceEdit.create = create;
12174 /**
12175 * Checks whether the given literal conforms to the {@link InsertReplaceEdit} interface.
12176 */
12177 function is(value) {
12178 const candidate = value;
12179 return candidate && Is.string(candidate.newText) && Range.is(candidate.insert) && Range.is(candidate.replace);
12180 }
12181 InsertReplaceEdit.is = is;
12182 })(InsertReplaceEdit || (InsertReplaceEdit = {}));
12183 /**
12184 * How whitespace and indentation is handled during completion
12185 * item insertion.
12186 *
12187 * @since 3.16.0
12188 */
12189 var InsertTextMode;
12190 (function (InsertTextMode) {
12191 /**
12192 * The insertion or replace strings is taken as it is. If the
12193 * value is multi line the lines below the cursor will be
12194 * inserted using the indentation defined in the string value.
12195 * The client will not apply any kind of adjustments to the
12196 * string.
12197 */
12198 InsertTextMode.asIs = 1;
12199 /**
12200 * The editor adjusts leading whitespace of new lines so that
12201 * they match the indentation up to the cursor of the line for
12202 * which the item is accepted.
12203 *
12204 * Consider a line like this: <2tabs><cursor><3tabs>foo. Accepting a
12205 * multi line completion item is indented using 2 tabs and all
12206 * following lines inserted will be indented using 2 tabs as well.
12207 */
12208 InsertTextMode.adjustIndentation = 2;
12209 })(InsertTextMode || (InsertTextMode = {}));
12210 var CompletionItemLabelDetails;
12211 (function (CompletionItemLabelDetails) {
12212 function is(value) {
12213 const candidate = value;
12214 return candidate && (Is.string(candidate.detail) || candidate.detail === undefined) &&
12215 (Is.string(candidate.description) || candidate.description === undefined);
12216 }
12217 CompletionItemLabelDetails.is = is;
12218 })(CompletionItemLabelDetails || (CompletionItemLabelDetails = {}));
12219 /**
12220 * The CompletionItem namespace provides functions to deal with
12221 * completion items.
12222 */
12223 var CompletionItem;
12224 (function (CompletionItem) {
12225 /**
12226 * Create a completion item and seed it with a label.
12227 * @param label The completion item's label
12228 */
12229 function create(label) {
12230 return { label };
12231 }
12232 CompletionItem.create = create;
12233 })(CompletionItem || (CompletionItem = {}));
12234 /**
12235 * The CompletionList namespace provides functions to deal with
12236 * completion lists.
12237 */
12238 var CompletionList;
12239 (function (CompletionList) {
12240 /**
12241 * Creates a new completion list.
12242 *
12243 * @param items The completion items.
12244 * @param isIncomplete The list is not complete.
12245 */
12246 function create(items, isIncomplete) {
12247 return { items: items ? items : [], isIncomplete: !!isIncomplete };
12248 }
12249 CompletionList.create = create;
12250 })(CompletionList || (CompletionList = {}));
12251 var MarkedString;
12252 (function (MarkedString) {
12253 /**
12254 * Creates a marked string from plain text.
12255 *
12256 * @param plainText The plain text.
12257 */
12258 function fromPlainText(plainText) {
12259 return plainText.replace(/[\\`*_{}[\]()#+\-.!]/g, '\\$&'); // escape markdown syntax tokens: http://daringfireball.net/projects/markdown/syntax#backslash
12260 }
12261 MarkedString.fromPlainText = fromPlainText;
12262 /**
12263 * Checks whether the given value conforms to the {@link MarkedString} type.
12264 */
12265 function is(value) {
12266 const candidate = value;
12267 return Is.string(candidate) || (Is.objectLiteral(candidate) && Is.string(candidate.language) && Is.string(candidate.value));
12268 }
12269 MarkedString.is = is;
12270 })(MarkedString || (MarkedString = {}));
12271 var Hover;
12272 (function (Hover) {
12273 /**
12274 * Checks whether the given value conforms to the {@link Hover} interface.
12275 */
12276 function is(value) {
12277 let candidate = value;
12278 return !!candidate && Is.objectLiteral(candidate) && (MarkupContent.is(candidate.contents) ||
12279 MarkedString.is(candidate.contents) ||
12280 Is.typedArray(candidate.contents, MarkedString.is)) && (value.range === undefined || Range.is(value.range));
12281 }
12282 Hover.is = is;
12283 })(Hover || (Hover = {}));
12284 /**
12285 * The ParameterInformation namespace provides helper functions to work with
12286 * {@link ParameterInformation} literals.
12287 */
12288 var ParameterInformation;
12289 (function (ParameterInformation) {
12290 /**
12291 * Creates a new parameter information literal.
12292 *
12293 * @param label A label string.
12294 * @param documentation A doc string.
12295 */
12296 function create(label, documentation) {
12297 return documentation ? { label, documentation } : { label };
12298 }
12299 ParameterInformation.create = create;
12300 })(ParameterInformation || (ParameterInformation = {}));
12301 /**
12302 * The SignatureInformation namespace provides helper functions to work with
12303 * {@link SignatureInformation} literals.
12304 */
12305 var SignatureInformation;
12306 (function (SignatureInformation) {
12307 function create(label, documentation, ...parameters) {
12308 let result = { label };
12309 if (Is.defined(documentation)) {
12310 result.documentation = documentation;
12311 }
12312 if (Is.defined(parameters)) {
12313 result.parameters = parameters;
12314 }
12315 else {
12316 result.parameters = [];
12317 }
12318 return result;
12319 }
12320 SignatureInformation.create = create;
12321 })(SignatureInformation || (SignatureInformation = {}));
12322 /**
12323 * A document highlight kind.
12324 */
12325 var DocumentHighlightKind;
12326 (function (DocumentHighlightKind) {
12327 /**
12328 * A textual occurrence.
12329 */
12330 DocumentHighlightKind.Text = 1;
12331 /**
12332 * Read-access of a symbol, like reading a variable.
12333 */
12334 DocumentHighlightKind.Read = 2;
12335 /**
12336 * Write-access of a symbol, like writing to a variable.
12337 */
12338 DocumentHighlightKind.Write = 3;
12339 })(DocumentHighlightKind || (DocumentHighlightKind = {}));
12340 /**
12341 * DocumentHighlight namespace to provide helper functions to work with
12342 * {@link DocumentHighlight} literals.
12343 */
12344 var DocumentHighlight;
12345 (function (DocumentHighlight) {
12346 /**
12347 * Create a DocumentHighlight object.
12348 * @param range The range the highlight applies to.
12349 * @param kind The highlight kind
12350 */
12351 function create(range, kind) {
12352 let result = { range };
12353 if (Is.number(kind)) {
12354 result.kind = kind;
12355 }
12356 return result;
12357 }
12358 DocumentHighlight.create = create;
12359 })(DocumentHighlight || (DocumentHighlight = {}));
12360 /**
12361 * A symbol kind.
12362 */
12363 var SymbolKind;
12364 (function (SymbolKind) {
12365 SymbolKind.File = 1;
12366 SymbolKind.Module = 2;
12367 SymbolKind.Namespace = 3;
12368 SymbolKind.Package = 4;
12369 SymbolKind.Class = 5;
12370 SymbolKind.Method = 6;
12371 SymbolKind.Property = 7;
12372 SymbolKind.Field = 8;
12373 SymbolKind.Constructor = 9;
12374 SymbolKind.Enum = 10;
12375 SymbolKind.Interface = 11;
12376 SymbolKind.Function = 12;
12377 SymbolKind.Variable = 13;
12378 SymbolKind.Constant = 14;
12379 SymbolKind.String = 15;
12380 SymbolKind.Number = 16;
12381 SymbolKind.Boolean = 17;
12382 SymbolKind.Array = 18;
12383 SymbolKind.Object = 19;
12384 SymbolKind.Key = 20;
12385 SymbolKind.Null = 21;
12386 SymbolKind.EnumMember = 22;
12387 SymbolKind.Struct = 23;
12388 SymbolKind.Event = 24;
12389 SymbolKind.Operator = 25;
12390 SymbolKind.TypeParameter = 26;
12391 })(SymbolKind || (SymbolKind = {}));
12392 /**
12393 * Symbol tags are extra annotations that tweak the rendering of a symbol.
12394 *
12395 * @since 3.16
12396 */
12397 var SymbolTag;
12398 (function (SymbolTag) {
12399 /**
12400 * Render a symbol as obsolete, usually using a strike-out.
12401 */
12402 SymbolTag.Deprecated = 1;
12403 })(SymbolTag || (SymbolTag = {}));
12404 var SymbolInformation;
12405 (function (SymbolInformation) {
12406 /**
12407 * Creates a new symbol information literal.
12408 *
12409 * @param name The name of the symbol.
12410 * @param kind The kind of the symbol.
12411 * @param range The range of the location of the symbol.
12412 * @param uri The resource of the location of symbol.
12413 * @param containerName The name of the symbol containing the symbol.
12414 */
12415 function create(name, kind, range, uri, containerName) {
12416 let result = {
12417 name,
12418 kind,
12419 location: { uri, range }
12420 };
12421 if (containerName) {
12422 result.containerName = containerName;
12423 }
12424 return result;
12425 }
12426 SymbolInformation.create = create;
12427 })(SymbolInformation || (SymbolInformation = {}));
12428 var WorkspaceSymbol;
12429 (function (WorkspaceSymbol) {
12430 /**
12431 * Create a new workspace symbol.
12432 *
12433 * @param name The name of the symbol.
12434 * @param kind The kind of the symbol.
12435 * @param uri The resource of the location of the symbol.
12436 * @param range An options range of the location.
12437 * @returns A WorkspaceSymbol.
12438 */
12439 function create(name, kind, uri, range) {
12440 return range !== undefined
12441 ? { name, kind, location: { uri, range } }
12442 : { name, kind, location: { uri } };
12443 }
12444 WorkspaceSymbol.create = create;
12445 })(WorkspaceSymbol || (WorkspaceSymbol = {}));
12446 var DocumentSymbol;
12447 (function (DocumentSymbol) {
12448 /**
12449 * Creates a new symbol information literal.
12450 *
12451 * @param name The name of the symbol.
12452 * @param detail The detail of the symbol.
12453 * @param kind The kind of the symbol.
12454 * @param range The range of the symbol.
12455 * @param selectionRange The selectionRange of the symbol.
12456 * @param children Children of the symbol.
12457 */
12458 function create(name, detail, kind, range, selectionRange, children) {
12459 let result = {
12460 name,
12461 detail,
12462 kind,
12463 range,
12464 selectionRange
12465 };
12466 if (children !== undefined) {
12467 result.children = children;
12468 }
12469 return result;
12470 }
12471 DocumentSymbol.create = create;
12472 /**
12473 * Checks whether the given literal conforms to the {@link DocumentSymbol} interface.
12474 */
12475 function is(value) {
12476 let candidate = value;
12477 return candidate &&
12478 Is.string(candidate.name) && Is.number(candidate.kind) &&
12479 Range.is(candidate.range) && Range.is(candidate.selectionRange) &&
12480 (candidate.detail === undefined || Is.string(candidate.detail)) &&
12481 (candidate.deprecated === undefined || Is.boolean(candidate.deprecated)) &&
12482 (candidate.children === undefined || Array.isArray(candidate.children)) &&
12483 (candidate.tags === undefined || Array.isArray(candidate.tags));
12484 }
12485 DocumentSymbol.is = is;
12486 })(DocumentSymbol || (DocumentSymbol = {}));
12487 /**
12488 * A set of predefined code action kinds
12489 */
12490 var CodeActionKind;
12491 (function (CodeActionKind) {
12492 /**
12493 * Empty kind.
12494 */
12495 CodeActionKind.Empty = '';
12496 /**
12497 * Base kind for quickfix actions: 'quickfix'
12498 */
12499 CodeActionKind.QuickFix = 'quickfix';
12500 /**
12501 * Base kind for refactoring actions: 'refactor'
12502 */
12503 CodeActionKind.Refactor = 'refactor';
12504 /**
12505 * Base kind for refactoring extraction actions: 'refactor.extract'
12506 *
12507 * Example extract actions:
12508 *
12509 * - Extract method
12510 * - Extract function
12511 * - Extract variable
12512 * - Extract interface from class
12513 * - ...
12514 */
12515 CodeActionKind.RefactorExtract = 'refactor.extract';
12516 /**
12517 * Base kind for refactoring inline actions: 'refactor.inline'
12518 *
12519 * Example inline actions:
12520 *
12521 * - Inline function
12522 * - Inline variable
12523 * - Inline constant
12524 * - ...
12525 */
12526 CodeActionKind.RefactorInline = 'refactor.inline';
12527 /**
12528 * Base kind for refactoring rewrite actions: 'refactor.rewrite'
12529 *
12530 * Example rewrite actions:
12531 *
12532 * - Convert JavaScript function to class
12533 * - Add or remove parameter
12534 * - Encapsulate field
12535 * - Make method static
12536 * - Move method to base class
12537 * - ...
12538 */
12539 CodeActionKind.RefactorRewrite = 'refactor.rewrite';
12540 /**
12541 * Base kind for source actions: `source`
12542 *
12543 * Source code actions apply to the entire file.
12544 */
12545 CodeActionKind.Source = 'source';
12546 /**
12547 * Base kind for an organize imports source action: `source.organizeImports`
12548 */
12549 CodeActionKind.SourceOrganizeImports = 'source.organizeImports';
12550 /**
12551 * Base kind for auto-fix source actions: `source.fixAll`.
12552 *
12553 * Fix all actions automatically fix errors that have a clear fix that do not require user input.
12554 * They should not suppress errors or perform unsafe fixes such as generating new types or classes.
12555 *
12556 * @since 3.15.0
12557 */
12558 CodeActionKind.SourceFixAll = 'source.fixAll';
12559 })(CodeActionKind || (CodeActionKind = {}));
12560 /**
12561 * The reason why code actions were requested.
12562 *
12563 * @since 3.17.0
12564 */
12565 var CodeActionTriggerKind;
12566 (function (CodeActionTriggerKind) {
12567 /**
12568 * Code actions were explicitly requested by the user or by an extension.
12569 */
12570 CodeActionTriggerKind.Invoked = 1;
12571 /**
12572 * Code actions were requested automatically.
12573 *
12574 * This typically happens when current selection in a file changes, but can
12575 * also be triggered when file content changes.
12576 */
12577 CodeActionTriggerKind.Automatic = 2;
12578 })(CodeActionTriggerKind || (CodeActionTriggerKind = {}));
12579 /**
12580 * The CodeActionContext namespace provides helper functions to work with
12581 * {@link CodeActionContext} literals.
12582 */
12583 var CodeActionContext;
12584 (function (CodeActionContext) {
12585 /**
12586 * Creates a new CodeActionContext literal.
12587 */
12588 function create(diagnostics, only, triggerKind) {
12589 let result = { diagnostics };
12590 if (only !== undefined && only !== null) {
12591 result.only = only;
12592 }
12593 if (triggerKind !== undefined && triggerKind !== null) {
12594 result.triggerKind = triggerKind;
12595 }
12596 return result;
12597 }
12598 CodeActionContext.create = create;
12599 /**
12600 * Checks whether the given literal conforms to the {@link CodeActionContext} interface.
12601 */
12602 function is(value) {
12603 let candidate = value;
12604 return Is.defined(candidate) && Is.typedArray(candidate.diagnostics, Diagnostic.is)
12605 && (candidate.only === undefined || Is.typedArray(candidate.only, Is.string))
12606 && (candidate.triggerKind === undefined || candidate.triggerKind === CodeActionTriggerKind.Invoked || candidate.triggerKind === CodeActionTriggerKind.Automatic);
12607 }
12608 CodeActionContext.is = is;
12609 })(CodeActionContext || (CodeActionContext = {}));
12610 var CodeAction;
12611 (function (CodeAction) {
12612 function create(title, kindOrCommandOrEdit, kind) {
12613 let result = { title };
12614 let checkKind = true;
12615 if (typeof kindOrCommandOrEdit === 'string') {
12616 checkKind = false;
12617 result.kind = kindOrCommandOrEdit;
12618 }
12619 else if (Command.is(kindOrCommandOrEdit)) {
12620 result.command = kindOrCommandOrEdit;
12621 }
12622 else {
12623 result.edit = kindOrCommandOrEdit;
12624 }
12625 if (checkKind && kind !== undefined) {
12626 result.kind = kind;
12627 }
12628 return result;
12629 }
12630 CodeAction.create = create;
12631 function is(value) {
12632 let candidate = value;
12633 return candidate && Is.string(candidate.title) &&
12634 (candidate.diagnostics === undefined || Is.typedArray(candidate.diagnostics, Diagnostic.is)) &&
12635 (candidate.kind === undefined || Is.string(candidate.kind)) &&
12636 (candidate.edit !== undefined || candidate.command !== undefined) &&
12637 (candidate.command === undefined || Command.is(candidate.command)) &&
12638 (candidate.isPreferred === undefined || Is.boolean(candidate.isPreferred)) &&
12639 (candidate.edit === undefined || WorkspaceEdit.is(candidate.edit));
12640 }
12641 CodeAction.is = is;
12642 })(CodeAction || (CodeAction = {}));
12643 /**
12644 * The CodeLens namespace provides helper functions to work with
12645 * {@link CodeLens} literals.
12646 */
12647 var CodeLens;
12648 (function (CodeLens) {
12649 /**
12650 * Creates a new CodeLens literal.
12651 */
12652 function create(range, data) {
12653 let result = { range };
12654 if (Is.defined(data)) {
12655 result.data = data;
12656 }
12657 return result;
12658 }
12659 CodeLens.create = create;
12660 /**
12661 * Checks whether the given literal conforms to the {@link CodeLens} interface.
12662 */
12663 function is(value) {
12664 let candidate = value;
12665 return Is.defined(candidate) && Range.is(candidate.range) && (Is.undefined(candidate.command) || Command.is(candidate.command));
12666 }
12667 CodeLens.is = is;
12668 })(CodeLens || (CodeLens = {}));
12669 /**
12670 * The FormattingOptions namespace provides helper functions to work with
12671 * {@link FormattingOptions} literals.
12672 */
12673 var FormattingOptions;
12674 (function (FormattingOptions) {
12675 /**
12676 * Creates a new FormattingOptions literal.
12677 */
12678 function create(tabSize, insertSpaces) {
12679 return { tabSize, insertSpaces };
12680 }
12681 FormattingOptions.create = create;
12682 /**
12683 * Checks whether the given literal conforms to the {@link FormattingOptions} interface.
12684 */
12685 function is(value) {
12686 let candidate = value;
12687 return Is.defined(candidate) && Is.uinteger(candidate.tabSize) && Is.boolean(candidate.insertSpaces);
12688 }
12689 FormattingOptions.is = is;
12690 })(FormattingOptions || (FormattingOptions = {}));
12691 /**
12692 * The DocumentLink namespace provides helper functions to work with
12693 * {@link DocumentLink} literals.
12694 */
12695 var DocumentLink;
12696 (function (DocumentLink) {
12697 /**
12698 * Creates a new DocumentLink literal.
12699 */
12700 function create(range, target, data) {
12701 return { range, target, data };
12702 }
12703 DocumentLink.create = create;
12704 /**
12705 * Checks whether the given literal conforms to the {@link DocumentLink} interface.
12706 */
12707 function is(value) {
12708 let candidate = value;
12709 return Is.defined(candidate) && Range.is(candidate.range) && (Is.undefined(candidate.target) || Is.string(candidate.target));
12710 }
12711 DocumentLink.is = is;
12712 })(DocumentLink || (DocumentLink = {}));
12713 /**
12714 * The SelectionRange namespace provides helper function to work with
12715 * SelectionRange literals.
12716 */
12717 var SelectionRange;
12718 (function (SelectionRange) {
12719 /**
12720 * Creates a new SelectionRange
12721 * @param range the range.
12722 * @param parent an optional parent.
12723 */
12724 function create(range, parent) {
12725 return { range, parent };
12726 }
12727 SelectionRange.create = create;
12728 function is(value) {
12729 let candidate = value;
12730 return Is.objectLiteral(candidate) && Range.is(candidate.range) && (candidate.parent === undefined || SelectionRange.is(candidate.parent));
12731 }
12732 SelectionRange.is = is;
12733 })(SelectionRange || (SelectionRange = {}));
12734 /**
12735 * A set of predefined token types. This set is not fixed
12736 * an clients can specify additional token types via the
12737 * corresponding client capabilities.
12738 *
12739 * @since 3.16.0
12740 */
12741 var SemanticTokenTypes;
12742 (function (SemanticTokenTypes) {
12743 SemanticTokenTypes["namespace"] = "namespace";
12744 /**
12745 * Represents a generic type. Acts as a fallback for types which can't be mapped to
12746 * a specific type like class or enum.
12747 */
12748 SemanticTokenTypes["type"] = "type";
12749 SemanticTokenTypes["class"] = "class";
12750 SemanticTokenTypes["enum"] = "enum";
12751 SemanticTokenTypes["interface"] = "interface";
12752 SemanticTokenTypes["struct"] = "struct";
12753 SemanticTokenTypes["typeParameter"] = "typeParameter";
12754 SemanticTokenTypes["parameter"] = "parameter";
12755 SemanticTokenTypes["variable"] = "variable";
12756 SemanticTokenTypes["property"] = "property";
12757 SemanticTokenTypes["enumMember"] = "enumMember";
12758 SemanticTokenTypes["event"] = "event";
12759 SemanticTokenTypes["function"] = "function";
12760 SemanticTokenTypes["method"] = "method";
12761 SemanticTokenTypes["macro"] = "macro";
12762 SemanticTokenTypes["keyword"] = "keyword";
12763 SemanticTokenTypes["modifier"] = "modifier";
12764 SemanticTokenTypes["comment"] = "comment";
12765 SemanticTokenTypes["string"] = "string";
12766 SemanticTokenTypes["number"] = "number";
12767 SemanticTokenTypes["regexp"] = "regexp";
12768 SemanticTokenTypes["operator"] = "operator";
12769 /**
12770 * @since 3.17.0
12771 */
12772 SemanticTokenTypes["decorator"] = "decorator";
12773 })(SemanticTokenTypes || (SemanticTokenTypes = {}));
12774 /**
12775 * A set of predefined token modifiers. This set is not fixed
12776 * an clients can specify additional token types via the
12777 * corresponding client capabilities.
12778 *
12779 * @since 3.16.0
12780 */
12781 var SemanticTokenModifiers;
12782 (function (SemanticTokenModifiers) {
12783 SemanticTokenModifiers["declaration"] = "declaration";
12784 SemanticTokenModifiers["definition"] = "definition";
12785 SemanticTokenModifiers["readonly"] = "readonly";
12786 SemanticTokenModifiers["static"] = "static";
12787 SemanticTokenModifiers["deprecated"] = "deprecated";
12788 SemanticTokenModifiers["abstract"] = "abstract";
12789 SemanticTokenModifiers["async"] = "async";
12790 SemanticTokenModifiers["modification"] = "modification";
12791 SemanticTokenModifiers["documentation"] = "documentation";
12792 SemanticTokenModifiers["defaultLibrary"] = "defaultLibrary";
12793 })(SemanticTokenModifiers || (SemanticTokenModifiers = {}));
12794 /**
12795 * @since 3.16.0
12796 */
12797 var SemanticTokens;
12798 (function (SemanticTokens) {
12799 function is(value) {
12800 const candidate = value;
12801 return Is.objectLiteral(candidate) && (candidate.resultId === undefined || typeof candidate.resultId === 'string') &&
12802 Array.isArray(candidate.data) && (candidate.data.length === 0 || typeof candidate.data[0] === 'number');
12803 }
12804 SemanticTokens.is = is;
12805 })(SemanticTokens || (SemanticTokens = {}));
12806 /**
12807 * The InlineValueText namespace provides functions to deal with InlineValueTexts.
12808 *
12809 * @since 3.17.0
12810 */
12811 var InlineValueText;
12812 (function (InlineValueText) {
12813 /**
12814 * Creates a new InlineValueText literal.
12815 */
12816 function create(range, text) {
12817 return { range, text };
12818 }
12819 InlineValueText.create = create;
12820 function is(value) {
12821 const candidate = value;
12822 return candidate !== undefined && candidate !== null && Range.is(candidate.range) && Is.string(candidate.text);
12823 }
12824 InlineValueText.is = is;
12825 })(InlineValueText || (InlineValueText = {}));
12826 /**
12827 * The InlineValueVariableLookup namespace provides functions to deal with InlineValueVariableLookups.
12828 *
12829 * @since 3.17.0
12830 */
12831 var InlineValueVariableLookup;
12832 (function (InlineValueVariableLookup) {
12833 /**
12834 * Creates a new InlineValueText literal.
12835 */
12836 function create(range, variableName, caseSensitiveLookup) {
12837 return { range, variableName, caseSensitiveLookup };
12838 }
12839 InlineValueVariableLookup.create = create;
12840 function is(value) {
12841 const candidate = value;
12842 return candidate !== undefined && candidate !== null && Range.is(candidate.range) && Is.boolean(candidate.caseSensitiveLookup)
12843 && (Is.string(candidate.variableName) || candidate.variableName === undefined);
12844 }
12845 InlineValueVariableLookup.is = is;
12846 })(InlineValueVariableLookup || (InlineValueVariableLookup = {}));
12847 /**
12848 * The InlineValueEvaluatableExpression namespace provides functions to deal with InlineValueEvaluatableExpression.
12849 *
12850 * @since 3.17.0
12851 */
12852 var InlineValueEvaluatableExpression;
12853 (function (InlineValueEvaluatableExpression) {
12854 /**
12855 * Creates a new InlineValueEvaluatableExpression literal.
12856 */
12857 function create(range, expression) {
12858 return { range, expression };
12859 }
12860 InlineValueEvaluatableExpression.create = create;
12861 function is(value) {
12862 const candidate = value;
12863 return candidate !== undefined && candidate !== null && Range.is(candidate.range)
12864 && (Is.string(candidate.expression) || candidate.expression === undefined);
12865 }
12866 InlineValueEvaluatableExpression.is = is;
12867 })(InlineValueEvaluatableExpression || (InlineValueEvaluatableExpression = {}));
12868 /**
12869 * The InlineValueContext namespace provides helper functions to work with
12870 * {@link InlineValueContext} literals.
12871 *
12872 * @since 3.17.0
12873 */
12874 var InlineValueContext;
12875 (function (InlineValueContext) {
12876 /**
12877 * Creates a new InlineValueContext literal.
12878 */
12879 function create(frameId, stoppedLocation) {
12880 return { frameId, stoppedLocation };
12881 }
12882 InlineValueContext.create = create;
12883 /**
12884 * Checks whether the given literal conforms to the {@link InlineValueContext} interface.
12885 */
12886 function is(value) {
12887 const candidate = value;
12888 return Is.defined(candidate) && Range.is(value.stoppedLocation);
12889 }
12890 InlineValueContext.is = is;
12891 })(InlineValueContext || (InlineValueContext = {}));
12892 /**
12893 * Inlay hint kinds.
12894 *
12895 * @since 3.17.0
12896 */
12897 var InlayHintKind;
12898 (function (InlayHintKind) {
12899 /**
12900 * An inlay hint that for a type annotation.
12901 */
12902 InlayHintKind.Type = 1;
12903 /**
12904 * An inlay hint that is for a parameter.
12905 */
12906 InlayHintKind.Parameter = 2;
12907 function is(value) {
12908 return value === 1 || value === 2;
12909 }
12910 InlayHintKind.is = is;
12911 })(InlayHintKind || (InlayHintKind = {}));
12912 var InlayHintLabelPart;
12913 (function (InlayHintLabelPart) {
12914 function create(value) {
12915 return { value };
12916 }
12917 InlayHintLabelPart.create = create;
12918 function is(value) {
12919 const candidate = value;
12920 return Is.objectLiteral(candidate)
12921 && (candidate.tooltip === undefined || Is.string(candidate.tooltip) || MarkupContent.is(candidate.tooltip))
12922 && (candidate.location === undefined || Location.is(candidate.location))
12923 && (candidate.command === undefined || Command.is(candidate.command));
12924 }
12925 InlayHintLabelPart.is = is;
12926 })(InlayHintLabelPart || (InlayHintLabelPart = {}));
12927 var InlayHint;
12928 (function (InlayHint) {
12929 function create(position, label, kind) {
12930 const result = { position, label };
12931 if (kind !== undefined) {
12932 result.kind = kind;
12933 }
12934 return result;
12935 }
12936 InlayHint.create = create;
12937 function is(value) {
12938 const candidate = value;
12939 return Is.objectLiteral(candidate) && Position.is(candidate.position)
12940 && (Is.string(candidate.label) || Is.typedArray(candidate.label, InlayHintLabelPart.is))
12941 && (candidate.kind === undefined || InlayHintKind.is(candidate.kind))
12942 && (candidate.textEdits === undefined) || Is.typedArray(candidate.textEdits, TextEdit.is)
12943 && (candidate.tooltip === undefined || Is.string(candidate.tooltip) || MarkupContent.is(candidate.tooltip))
12944 && (candidate.paddingLeft === undefined || Is.boolean(candidate.paddingLeft))
12945 && (candidate.paddingRight === undefined || Is.boolean(candidate.paddingRight));
12946 }
12947 InlayHint.is = is;
12948 })(InlayHint || (InlayHint = {}));
12949 var StringValue;
12950 (function (StringValue) {
12951 function createSnippet(value) {
12952 return { kind: 'snippet', value };
12953 }
12954 StringValue.createSnippet = createSnippet;
12955 })(StringValue || (StringValue = {}));
12956 var InlineCompletionItem;
12957 (function (InlineCompletionItem) {
12958 function create(insertText, filterText, range, command) {
12959 return { insertText, filterText, range, command };
12960 }
12961 InlineCompletionItem.create = create;
12962 })(InlineCompletionItem || (InlineCompletionItem = {}));
12963 var InlineCompletionList;
12964 (function (InlineCompletionList) {
12965 function create(items) {
12966 return { items };
12967 }
12968 InlineCompletionList.create = create;
12969 })(InlineCompletionList || (InlineCompletionList = {}));
12970 /**
12971 * Describes how an {@link InlineCompletionItemProvider inline completion provider} was triggered.
12972 *
12973 * @since 3.18.0
12974 * @proposed
12975 */
12976 var InlineCompletionTriggerKind;
12977 (function (InlineCompletionTriggerKind) {
12978 /**
12979 * Completion was triggered explicitly by a user gesture.
12980 */
12981 InlineCompletionTriggerKind.Invoked = 0;
12982 /**
12983 * Completion was triggered automatically while editing.
12984 */
12985 InlineCompletionTriggerKind.Automatic = 1;
12986 })(InlineCompletionTriggerKind || (InlineCompletionTriggerKind = {}));
12987 var SelectedCompletionInfo;
12988 (function (SelectedCompletionInfo) {
12989 function create(range, text) {
12990 return { range, text };
12991 }
12992 SelectedCompletionInfo.create = create;
12993 })(SelectedCompletionInfo || (SelectedCompletionInfo = {}));
12994 var InlineCompletionContext;
12995 (function (InlineCompletionContext) {
12996 function create(triggerKind, selectedCompletionInfo) {
12997 return { triggerKind, selectedCompletionInfo };
12998 }
12999 InlineCompletionContext.create = create;
13000 })(InlineCompletionContext || (InlineCompletionContext = {}));
13001 var WorkspaceFolder;
13002 (function (WorkspaceFolder) {
13003 function is(value) {
13004 const candidate = value;
13005 return Is.objectLiteral(candidate) && URI.is(candidate.uri) && Is.string(candidate.name);
13006 }
13007 WorkspaceFolder.is = is;
13008 })(WorkspaceFolder || (WorkspaceFolder = {}));
13009 const EOL = (/* unused pure expression or super */ null && (['\n', '\r\n', '\r']));
13010 /**
13011 * @deprecated Use the text document from the new vscode-languageserver-textdocument package.
13012 */
13013 var TextDocument;
13014 (function (TextDocument) {
13015 /**
13016 * Creates a new ITextDocument literal from the given uri and content.
13017 * @param uri The document's uri.
13018 * @param languageId The document's language Id.
13019 * @param version The document's version.
13020 * @param content The document's content.
13021 */
13022 function create(uri, languageId, version, content) {
13023 return new FullTextDocument(uri, languageId, version, content);
13024 }
13025 TextDocument.create = create;
13026 /**
13027 * Checks whether the given literal conforms to the {@link ITextDocument} interface.
13028 */
13029 function is(value) {
13030 let candidate = value;
13031 return Is.defined(candidate) && Is.string(candidate.uri) && (Is.undefined(candidate.languageId) || Is.string(candidate.languageId)) && Is.uinteger(candidate.lineCount)
13032 && Is.func(candidate.getText) && Is.func(candidate.positionAt) && Is.func(candidate.offsetAt) ? true : false;
13033 }
13034 TextDocument.is = is;
13035 function applyEdits(document, edits) {
13036 let text = document.getText();
13037 let sortedEdits = mergeSort(edits, (a, b) => {
13038 let diff = a.range.start.line - b.range.start.line;
13039 if (diff === 0) {
13040 return a.range.start.character - b.range.start.character;
13041 }
13042 return diff;
13043 });
13044 let lastModifiedOffset = text.length;
13045 for (let i = sortedEdits.length - 1; i >= 0; i--) {
13046 let e = sortedEdits[i];
13047 let startOffset = document.offsetAt(e.range.start);
13048 let endOffset = document.offsetAt(e.range.end);
13049 if (endOffset <= lastModifiedOffset) {
13050 text = text.substring(0, startOffset) + e.newText + text.substring(endOffset, text.length);
13051 }
13052 else {
13053 throw new Error('Overlapping edit');
13054 }
13055 lastModifiedOffset = startOffset;
13056 }
13057 return text;
13058 }
13059 TextDocument.applyEdits = applyEdits;
13060 function mergeSort(data, compare) {
13061 if (data.length <= 1) {
13062 // sorted
13063 return data;
13064 }
13065 const p = (data.length / 2) | 0;
13066 const left = data.slice(0, p);
13067 const right = data.slice(p);
13068 mergeSort(left, compare);
13069 mergeSort(right, compare);
13070 let leftIdx = 0;
13071 let rightIdx = 0;
13072 let i = 0;
13073 while (leftIdx < left.length && rightIdx < right.length) {
13074 let ret = compare(left[leftIdx], right[rightIdx]);
13075 if (ret <= 0) {
13076 // smaller_equal -> take left to preserve order
13077 data[i++] = left[leftIdx++];
13078 }
13079 else {
13080 // greater -> take right
13081 data[i++] = right[rightIdx++];
13082 }
13083 }
13084 while (leftIdx < left.length) {
13085 data[i++] = left[leftIdx++];
13086 }
13087 while (rightIdx < right.length) {
13088 data[i++] = right[rightIdx++];
13089 }
13090 return data;
13091 }
13092 })(TextDocument || (TextDocument = {}));
13093 /**
13094 * @deprecated Use the text document from the new vscode-languageserver-textdocument package.
13095 */
13096 class FullTextDocument {
13097 constructor(uri, languageId, version, content) {
13098 this._uri = uri;
13099 this._languageId = languageId;
13100 this._version = version;
13101 this._content = content;
13102 this._lineOffsets = undefined;
13103 }
13104 get uri() {
13105 return this._uri;
13106 }
13107 get languageId() {
13108 return this._languageId;
13109 }
13110 get version() {
13111 return this._version;
13112 }
13113 getText(range) {
13114 if (range) {
13115 let start = this.offsetAt(range.start);
13116 let end = this.offsetAt(range.end);
13117 return this._content.substring(start, end);
13118 }
13119 return this._content;
13120 }
13121 update(event, version) {
13122 this._content = event.text;
13123 this._version = version;
13124 this._lineOffsets = undefined;
13125 }
13126 getLineOffsets() {
13127 if (this._lineOffsets === undefined) {
13128 let lineOffsets = [];
13129 let text = this._content;
13130 let isLineStart = true;
13131 for (let i = 0; i < text.length; i++) {
13132 if (isLineStart) {
13133 lineOffsets.push(i);
13134 isLineStart = false;
13135 }
13136 let ch = text.charAt(i);
13137 isLineStart = (ch === '\r' || ch === '\n');
13138 if (ch === '\r' && i + 1 < text.length && text.charAt(i + 1) === '\n') {
13139 i++;
13140 }
13141 }
13142 if (isLineStart && text.length > 0) {
13143 lineOffsets.push(text.length);
13144 }
13145 this._lineOffsets = lineOffsets;
13146 }
13147 return this._lineOffsets;
13148 }
13149 positionAt(offset) {
13150 offset = Math.max(Math.min(offset, this._content.length), 0);
13151 let lineOffsets = this.getLineOffsets();
13152 let low = 0, high = lineOffsets.length;
13153 if (high === 0) {
13154 return Position.create(0, offset);
13155 }
13156 while (low < high) {
13157 let mid = Math.floor((low + high) / 2);
13158 if (lineOffsets[mid] > offset) {
13159 high = mid;
13160 }
13161 else {
13162 low = mid + 1;
13163 }
13164 }
13165 // low is the least x for which the line offset is larger than the current offset
13166 // or array.length if no line offset is larger than the current offset
13167 let line = low - 1;
13168 return Position.create(line, offset - lineOffsets[line]);
13169 }
13170 offsetAt(position) {
13171 let lineOffsets = this.getLineOffsets();
13172 if (position.line >= lineOffsets.length) {
13173 return this._content.length;
13174 }
13175 else if (position.line < 0) {
13176 return 0;
13177 }
13178 let lineOffset = lineOffsets[position.line];
13179 let nextLineOffset = (position.line + 1 < lineOffsets.length) ? lineOffsets[position.line + 1] : this._content.length;
13180 return Math.max(Math.min(lineOffset + position.character, nextLineOffset), lineOffset);
13181 }
13182 get lineCount() {
13183 return this.getLineOffsets().length;
13184 }
13185 }
13186 var Is;
13187 (function (Is) {
13188 const toString = Object.prototype.toString;
13189 function defined(value) {
13190 return typeof value !== 'undefined';
13191 }
13192 Is.defined = defined;
13193 function undefined(value) {
13194 return typeof value === 'undefined';
13195 }
13196 Is.undefined = undefined;
13197 function boolean(value) {
13198 return value === true || value === false;
13199 }
13200 Is.boolean = boolean;
13201 function string(value) {
13202 return toString.call(value) === '[object String]';
13203 }
13204 Is.string = string;
13205 function number(value) {
13206 return toString.call(value) === '[object Number]';
13207 }
13208 Is.number = number;
13209 function numberRange(value, min, max) {
13210 return toString.call(value) === '[object Number]' && min <= value && value <= max;
13211 }
13212 Is.numberRange = numberRange;
13213 function integer(value) {
13214 return toString.call(value) === '[object Number]' && -2147483648 <= value && value <= 2147483647;
13215 }
13216 Is.integer = integer;
13217 function uinteger(value) {
13218 return toString.call(value) === '[object Number]' && 0 <= value && value <= 2147483647;
13219 }
13220 Is.uinteger = uinteger;
13221 function func(value) {
13222 return toString.call(value) === '[object Function]';
13223 }
13224 Is.func = func;
13225 function objectLiteral(value) {
13226 // Strictly speaking class instances pass this check as well. Since the LSP
13227 // doesn't use classes we ignore this for now. If we do we need to add something
13228 // like this: `Object.getPrototypeOf(Object.getPrototypeOf(x)) === null`
13229 return value !== null && typeof value === 'object';
13230 }
13231 Is.objectLiteral = objectLiteral;
13232 function typedArray(value, check) {
13233 return Array.isArray(value) && value.every(check);
13234 }
13235 Is.typedArray = typedArray;
13236 })(Is || (Is = {}));
13237
13238 ;// CONCATENATED MODULE: ../node_modules/langium/lib/parser/cst-node-builder.js
13239 /******************************************************************************
13240 * Copyright 2021 TypeFox GmbH
13241 * This program and the accompanying materials are made available under the
13242 * terms of the MIT License, which is available in the project root.
13243 ******************************************************************************/
13244
13245
13246 class CstNodeBuilder {
13247 constructor() {
13248 this.nodeStack = [];
13249 }
13250 get current() {
13251 var _a;
13252 return (_a = this.nodeStack[this.nodeStack.length - 1]) !== null && _a !== void 0 ? _a : this.rootNode;
13253 }
13254 buildRootNode(input) {
13255 this.rootNode = new RootCstNodeImpl(input);
13256 this.rootNode.root = this.rootNode;
13257 this.nodeStack = [this.rootNode];
13258 return this.rootNode;
13259 }
13260 buildCompositeNode(feature) {
13261 const compositeNode = new CompositeCstNodeImpl();
13262 compositeNode.grammarSource = feature;
13263 compositeNode.root = this.rootNode;
13264 this.current.content.push(compositeNode);
13265 this.nodeStack.push(compositeNode);
13266 return compositeNode;
13267 }
13268 buildLeafNode(token, feature) {
13269 const leafNode = new LeafCstNodeImpl(token.startOffset, token.image.length, (0,cst_utils/* tokenToRange */.sp)(token), token.tokenType, !feature);
13270 leafNode.grammarSource = feature;
13271 leafNode.root = this.rootNode;
13272 this.current.content.push(leafNode);
13273 return leafNode;
13274 }
13275 removeNode(node) {
13276 const parent = node.container;
13277 if (parent) {
13278 const index = parent.content.indexOf(node);
13279 if (index >= 0) {
13280 parent.content.splice(index, 1);
13281 }
13282 }
13283 }
13284 addHiddenNodes(tokens) {
13285 const nodes = [];
13286 for (const token of tokens) {
13287 const leafNode = new LeafCstNodeImpl(token.startOffset, token.image.length, (0,cst_utils/* tokenToRange */.sp)(token), token.tokenType, true);
13288 leafNode.root = this.rootNode;
13289 nodes.push(leafNode);
13290 }
13291 let current = this.current;
13292 let added = false;
13293 // If we are within a composite node, we add the hidden nodes to the content
13294 if (current.content.length > 0) {
13295 current.content.push(...nodes);
13296 return;
13297 }
13298 // Otherwise we are at a newly created node
13299 // Instead of adding the hidden nodes here, we search for the first parent node with content
13300 while (current.container) {
13301 const index = current.container.content.indexOf(current);
13302 if (index > 0) {
13303 // Add the hidden nodes before the current node
13304 current.container.content.splice(index, 0, ...nodes);
13305 added = true;
13306 break;
13307 }
13308 current = current.container;
13309 }
13310 // If we arrive at the root node, we add the hidden nodes at the beginning
13311 // This is the case if the hidden nodes are the first nodes in the tree
13312 if (!added) {
13313 this.rootNode.content.unshift(...nodes);
13314 }
13315 }
13316 construct(item) {
13317 const current = this.current;
13318 // The specified item could be a datatype ($type is symbol) or a fragment ($type is undefined)
13319 // Only if the $type is a string, we actually assign the element
13320 if (typeof item.$type === 'string') {
13321 this.current.astNode = item;
13322 }
13323 item.$cstNode = current;
13324 const node = this.nodeStack.pop();
13325 // Empty composite nodes are not valid
13326 // Simply remove the node from the tree
13327 if ((node === null || node === void 0 ? void 0 : node.content.length) === 0) {
13328 this.removeNode(node);
13329 }
13330 }
13331 }
13332 class AbstractCstNode {
13333 /** @deprecated use `container` instead. */
13334 get parent() {
13335 return this.container;
13336 }
13337 /** @deprecated use `grammarSource` instead. */
13338 get feature() {
13339 return this.grammarSource;
13340 }
13341 get hidden() {
13342 return false;
13343 }
13344 get astNode() {
13345 var _a, _b;
13346 const node = typeof ((_a = this._astNode) === null || _a === void 0 ? void 0 : _a.$type) === 'string' ? this._astNode : (_b = this.container) === null || _b === void 0 ? void 0 : _b.astNode;
13347 if (!node) {
13348 throw new Error('This node has no associated AST element');
13349 }
13350 return node;
13351 }
13352 set astNode(value) {
13353 this._astNode = value;
13354 }
13355 /** @deprecated use `astNode` instead. */
13356 get element() {
13357 return this.astNode;
13358 }
13359 get text() {
13360 return this.root.fullText.substring(this.offset, this.end);
13361 }
13362 }
13363 class LeafCstNodeImpl extends AbstractCstNode {
13364 get offset() {
13365 return this._offset;
13366 }
13367 get length() {
13368 return this._length;
13369 }
13370 get end() {
13371 return this._offset + this._length;
13372 }
13373 get hidden() {
13374 return this._hidden;
13375 }
13376 get tokenType() {
13377 return this._tokenType;
13378 }
13379 get range() {
13380 return this._range;
13381 }
13382 constructor(offset, length, range, tokenType, hidden = false) {
13383 super();
13384 this._hidden = hidden;
13385 this._offset = offset;
13386 this._tokenType = tokenType;
13387 this._length = length;
13388 this._range = range;
13389 }
13390 }
13391 class CompositeCstNodeImpl extends AbstractCstNode {
13392 constructor() {
13393 super(...arguments);
13394 this.content = new CstNodeContainer(this);
13395 }
13396 /** @deprecated use `content` instead. */
13397 get children() {
13398 return this.content;
13399 }
13400 get offset() {
13401 var _a, _b;
13402 return (_b = (_a = this.firstNonHiddenNode) === null || _a === void 0 ? void 0 : _a.offset) !== null && _b !== void 0 ? _b : 0;
13403 }
13404 get length() {
13405 return this.end - this.offset;
13406 }
13407 get end() {
13408 var _a, _b;
13409 return (_b = (_a = this.lastNonHiddenNode) === null || _a === void 0 ? void 0 : _a.end) !== null && _b !== void 0 ? _b : 0;
13410 }
13411 get range() {
13412 const firstNode = this.firstNonHiddenNode;
13413 const lastNode = this.lastNonHiddenNode;
13414 if (firstNode && lastNode) {
13415 if (this._rangeCache === undefined) {
13416 const { range: firstRange } = firstNode;
13417 const { range: lastRange } = lastNode;
13418 this._rangeCache = { start: firstRange.start, end: lastRange.end.line < firstRange.start.line ? firstRange.start : lastRange.end };
13419 }
13420 return this._rangeCache;
13421 }
13422 else {
13423 return { start: Position.create(0, 0), end: Position.create(0, 0) };
13424 }
13425 }
13426 get firstNonHiddenNode() {
13427 for (const child of this.content) {
13428 if (!child.hidden) {
13429 return child;
13430 }
13431 }
13432 return this.content[0];
13433 }
13434 get lastNonHiddenNode() {
13435 for (let i = this.content.length - 1; i >= 0; i--) {
13436 const child = this.content[i];
13437 if (!child.hidden) {
13438 return child;
13439 }
13440 }
13441 return this.content[this.content.length - 1];
13442 }
13443 }
13444 class CstNodeContainer extends Array {
13445 constructor(parent) {
13446 super();
13447 this.parent = parent;
13448 Object.setPrototypeOf(this, CstNodeContainer.prototype);
13449 }
13450 push(...items) {
13451 this.addParents(items);
13452 return super.push(...items);
13453 }
13454 unshift(...items) {
13455 this.addParents(items);
13456 return super.unshift(...items);
13457 }
13458 splice(start, count, ...items) {
13459 this.addParents(items);
13460 return super.splice(start, count, ...items);
13461 }
13462 addParents(items) {
13463 for (const item of items) {
13464 item.container = this.parent;
13465 }
13466 }
13467 }
13468 class RootCstNodeImpl extends CompositeCstNodeImpl {
13469 get text() {
13470 return this._text.substring(this.offset, this.end);
13471 }
13472 get fullText() {
13473 return this._text;
13474 }
13475 constructor(input) {
13476 super();
13477 this._text = '';
13478 this._text = input !== null && input !== void 0 ? input : '';
13479 }
13480 }
13481 //# sourceMappingURL=cst-node-builder.js.map
13482 ;// CONCATENATED MODULE: ../node_modules/langium/lib/parser/langium-parser.js
13483 /******************************************************************************
13484 * Copyright 2021 TypeFox GmbH
13485 * This program and the accompanying materials are made available under the
13486 * terms of the MIT License, which is available in the project root.
13487 ******************************************************************************/
13488
13489
13490
13491
13492
13493
13494 const DatatypeSymbol = Symbol('Datatype');
13495 function isDataTypeNode(node) {
13496 return node.$type === DatatypeSymbol;
13497 }
13498 const ruleSuffix = '\u200B';
13499 const withRuleSuffix = (name) => name.endsWith(ruleSuffix) ? name : name + ruleSuffix;
13500 class AbstractLangiumParser {
13501 constructor(services) {
13502 this._unorderedGroups = new Map();
13503 this.allRules = new Map();
13504 this.lexer = services.parser.Lexer;
13505 const tokens = this.lexer.definition;
13506 const production = services.LanguageMetaData.mode === 'production';
13507 this.wrapper = new ChevrotainWrapper(tokens, Object.assign(Object.assign({}, services.parser.ParserConfig), { skipValidations: production, errorMessageProvider: services.parser.ParserErrorMessageProvider }));
13508 }
13509 alternatives(idx, choices) {
13510 this.wrapper.wrapOr(idx, choices);
13511 }
13512 optional(idx, callback) {
13513 this.wrapper.wrapOption(idx, callback);
13514 }
13515 many(idx, callback) {
13516 this.wrapper.wrapMany(idx, callback);
13517 }
13518 atLeastOne(idx, callback) {
13519 this.wrapper.wrapAtLeastOne(idx, callback);
13520 }
13521 getRule(name) {
13522 return this.allRules.get(name);
13523 }
13524 isRecording() {
13525 return this.wrapper.IS_RECORDING;
13526 }
13527 get unorderedGroups() {
13528 return this._unorderedGroups;
13529 }
13530 getRuleStack() {
13531 return this.wrapper.RULE_STACK;
13532 }
13533 finalize() {
13534 this.wrapper.wrapSelfAnalysis();
13535 }
13536 }
13537 class LangiumParser extends AbstractLangiumParser {
13538 get current() {
13539 return this.stack[this.stack.length - 1];
13540 }
13541 constructor(services) {
13542 super(services);
13543 this.nodeBuilder = new CstNodeBuilder();
13544 this.stack = [];
13545 this.assignmentMap = new Map();
13546 this.linker = services.references.Linker;
13547 this.converter = services.parser.ValueConverter;
13548 this.astReflection = services.shared.AstReflection;
13549 }
13550 rule(rule, impl) {
13551 const type = this.computeRuleType(rule);
13552 const ruleMethod = this.wrapper.DEFINE_RULE(withRuleSuffix(rule.name), this.startImplementation(type, impl).bind(this));
13553 this.allRules.set(rule.name, ruleMethod);
13554 if (rule.entry) {
13555 this.mainRule = ruleMethod;
13556 }
13557 return ruleMethod;
13558 }
13559 computeRuleType(rule) {
13560 if (rule.fragment) {
13561 return undefined;
13562 }
13563 else if ((0,grammar_utils/* isDataTypeRule */.UP)(rule)) {
13564 return DatatypeSymbol;
13565 }
13566 else {
13567 const explicit = (0,grammar_utils/* getExplicitRuleType */.$G)(rule);
13568 return explicit !== null && explicit !== void 0 ? explicit : rule.name;
13569 }
13570 }
13571 parse(input, options = {}) {
13572 this.nodeBuilder.buildRootNode(input);
13573 const lexerResult = this.lexerResult = this.lexer.tokenize(input);
13574 this.wrapper.input = lexerResult.tokens;
13575 const ruleMethod = options.rule ? this.allRules.get(options.rule) : this.mainRule;
13576 if (!ruleMethod) {
13577 throw new Error(options.rule ? `No rule found with name '${options.rule}'` : 'No main rule available.');
13578 }
13579 const result = ruleMethod.call(this.wrapper, {});
13580 this.nodeBuilder.addHiddenNodes(lexerResult.hidden);
13581 this.unorderedGroups.clear();
13582 this.lexerResult = undefined;
13583 return {
13584 value: result,
13585 lexerErrors: lexerResult.errors,
13586 lexerReport: lexerResult.report,
13587 parserErrors: this.wrapper.errors
13588 };
13589 }
13590 startImplementation($type, implementation) {
13591 return (args) => {
13592 // Only create a new AST node in case the calling rule is not a fragment rule
13593 const createNode = !this.isRecording() && $type !== undefined;
13594 if (createNode) {
13595 const node = { $type };
13596 this.stack.push(node);
13597 if ($type === DatatypeSymbol) {
13598 node.value = '';
13599 }
13600 }
13601 let result;
13602 try {
13603 result = implementation(args);
13604 }
13605 catch (err) {
13606 result = undefined;
13607 }
13608 if (result === undefined && createNode) {
13609 result = this.construct();
13610 }
13611 return result;
13612 };
13613 }
13614 extractHiddenTokens(token) {
13615 const hiddenTokens = this.lexerResult.hidden;
13616 if (!hiddenTokens.length) {
13617 return [];
13618 }
13619 const offset = token.startOffset;
13620 for (let i = 0; i < hiddenTokens.length; i++) {
13621 const token = hiddenTokens[i];
13622 if (token.startOffset > offset) {
13623 return hiddenTokens.splice(0, i);
13624 }
13625 }
13626 return hiddenTokens.splice(0, hiddenTokens.length);
13627 }
13628 consume(idx, tokenType, feature) {
13629 const token = this.wrapper.wrapConsume(idx, tokenType);
13630 if (!this.isRecording() && this.isValidToken(token)) {
13631 const hiddenTokens = this.extractHiddenTokens(token);
13632 this.nodeBuilder.addHiddenNodes(hiddenTokens);
13633 const leafNode = this.nodeBuilder.buildLeafNode(token, feature);
13634 const { assignment, isCrossRef } = this.getAssignment(feature);
13635 const current = this.current;
13636 if (assignment) {
13637 const convertedValue = (0,ast/* isKeyword */.p1)(feature) ? token.image : this.converter.convert(token.image, leafNode);
13638 this.assign(assignment.operator, assignment.feature, convertedValue, leafNode, isCrossRef);
13639 }
13640 else if (isDataTypeNode(current)) {
13641 let text = token.image;
13642 if (!(0,ast/* isKeyword */.p1)(feature)) {
13643 text = this.converter.convert(text, leafNode).toString();
13644 }
13645 current.value += text;
13646 }
13647 }
13648 }
13649 /**
13650 * Most consumed parser tokens are valid. However there are two cases in which they are not valid:
13651 *
13652 * 1. They were inserted during error recovery by the parser. These tokens don't really exist and should not be further processed
13653 * 2. They contain invalid token ranges. This might include the special EOF token, or other tokens produced by invalid token builders.
13654 */
13655 isValidToken(token) {
13656 return !token.isInsertedInRecovery && !isNaN(token.startOffset) && typeof token.endOffset === 'number' && !isNaN(token.endOffset);
13657 }
13658 subrule(idx, rule, fragment, feature, args) {
13659 let cstNode;
13660 if (!this.isRecording() && !fragment) {
13661 // We only want to create a new CST node if the subrule actually creates a new AST node.
13662 // In other cases like calls of fragment rules the current CST/AST is populated further.
13663 // Note that skipping this initialization and leaving cstNode unassigned also skips the subrule assignment later on.
13664 // This is intended, as fragment rules only enrich the current AST node
13665 cstNode = this.nodeBuilder.buildCompositeNode(feature);
13666 }
13667 const subruleResult = this.wrapper.wrapSubrule(idx, rule, args);
13668 if (!this.isRecording() && cstNode && cstNode.length > 0) {
13669 this.performSubruleAssignment(subruleResult, feature, cstNode);
13670 }
13671 }
13672 performSubruleAssignment(result, feature, cstNode) {
13673 const { assignment, isCrossRef } = this.getAssignment(feature);
13674 if (assignment) {
13675 this.assign(assignment.operator, assignment.feature, result, cstNode, isCrossRef);
13676 }
13677 else if (!assignment) {
13678 // If we call a subrule without an assignment we either:
13679 // 1. append the result of the subrule (data type rule)
13680 // 2. override the current object with the newly parsed object
13681 // If the current element is an AST node and the result of the subrule
13682 // is a data type rule, we can safely discard the results.
13683 const current = this.current;
13684 if (isDataTypeNode(current)) {
13685 current.value += result.toString();
13686 }
13687 else if (typeof result === 'object' && result) {
13688 const object = this.assignWithoutOverride(result, current);
13689 const newItem = object;
13690 this.stack.pop();
13691 this.stack.push(newItem);
13692 }
13693 }
13694 }
13695 action($type, action) {
13696 if (!this.isRecording()) {
13697 let last = this.current;
13698 if (action.feature && action.operator) {
13699 last = this.construct();
13700 this.nodeBuilder.removeNode(last.$cstNode);
13701 const node = this.nodeBuilder.buildCompositeNode(action);
13702 node.content.push(last.$cstNode);
13703 const newItem = { $type };
13704 this.stack.push(newItem);
13705 this.assign(action.operator, action.feature, last, last.$cstNode, false);
13706 }
13707 else {
13708 last.$type = $type;
13709 }
13710 }
13711 }
13712 construct() {
13713 if (this.isRecording()) {
13714 return undefined;
13715 }
13716 const obj = this.current;
13717 (0,ast_utils/* linkContentToContainer */.b2)(obj);
13718 this.nodeBuilder.construct(obj);
13719 this.stack.pop();
13720 if (isDataTypeNode(obj)) {
13721 return this.converter.convert(obj.value, obj.$cstNode);
13722 }
13723 else {
13724 (0,ast_utils/* assignMandatoryProperties */.a1)(this.astReflection, obj);
13725 }
13726 return obj;
13727 }
13728 getAssignment(feature) {
13729 if (!this.assignmentMap.has(feature)) {
13730 const assignment = (0,ast_utils/* getContainerOfType */.V_)(feature, ast/* isAssignment */.B7);
13731 this.assignmentMap.set(feature, {
13732 assignment: assignment,
13733 isCrossRef: assignment ? (0,ast/* isCrossReference */.Ki)(assignment.terminal) : false
13734 });
13735 }
13736 return this.assignmentMap.get(feature);
13737 }
13738 assign(operator, feature, value, cstNode, isCrossRef) {
13739 const obj = this.current;
13740 let item;
13741 if (isCrossRef && typeof value === 'string') {
13742 item = this.linker.buildReference(obj, feature, cstNode, value);
13743 }
13744 else {
13745 item = value;
13746 }
13747 switch (operator) {
13748 case '=': {
13749 obj[feature] = item;
13750 break;
13751 }
13752 case '?=': {
13753 obj[feature] = true;
13754 break;
13755 }
13756 case '+=': {
13757 if (!Array.isArray(obj[feature])) {
13758 obj[feature] = [];
13759 }
13760 obj[feature].push(item);
13761 }
13762 }
13763 }
13764 assignWithoutOverride(target, source) {
13765 for (const [name, existingValue] of Object.entries(source)) {
13766 const newValue = target[name];
13767 if (newValue === undefined) {
13768 target[name] = existingValue;
13769 }
13770 else if (Array.isArray(newValue) && Array.isArray(existingValue)) {
13771 existingValue.push(...newValue);
13772 target[name] = existingValue;
13773 }
13774 }
13775 // The target was parsed from a unassigned subrule
13776 // After the subrule construction, it received a cst node
13777 // This CST node will later be overriden by the cst node builder
13778 // To prevent references to stale AST nodes in the CST,
13779 // we need to remove the reference here
13780 const targetCstNode = target.$cstNode;
13781 if (targetCstNode) {
13782 targetCstNode.astNode = undefined;
13783 target.$cstNode = undefined;
13784 }
13785 return target;
13786 }
13787 get definitionErrors() {
13788 return this.wrapper.definitionErrors;
13789 }
13790 }
13791 class AbstractParserErrorMessageProvider {
13792 buildMismatchTokenMessage(options) {
13793 return api/* defaultParserErrorProvider */.Hs.buildMismatchTokenMessage(options);
13794 }
13795 buildNotAllInputParsedMessage(options) {
13796 return api/* defaultParserErrorProvider */.Hs.buildNotAllInputParsedMessage(options);
13797 }
13798 buildNoViableAltMessage(options) {
13799 return api/* defaultParserErrorProvider */.Hs.buildNoViableAltMessage(options);
13800 }
13801 buildEarlyExitMessage(options) {
13802 return api/* defaultParserErrorProvider */.Hs.buildEarlyExitMessage(options);
13803 }
13804 }
13805 class LangiumParserErrorMessageProvider extends AbstractParserErrorMessageProvider {
13806 buildMismatchTokenMessage({ expected, actual }) {
13807 const expectedMsg = expected.LABEL
13808 ? '`' + expected.LABEL + '`'
13809 : expected.name.endsWith(':KW')
13810 ? `keyword '${expected.name.substring(0, expected.name.length - 3)}'`
13811 : `token of type '${expected.name}'`;
13812 return `Expecting ${expectedMsg} but found \`${actual.image}\`.`;
13813 }
13814 buildNotAllInputParsedMessage({ firstRedundant }) {
13815 return `Expecting end of file but found \`${firstRedundant.image}\`.`;
13816 }
13817 }
13818 class LangiumCompletionParser extends AbstractLangiumParser {
13819 constructor() {
13820 super(...arguments);
13821 this.tokens = [];
13822 this.elementStack = [];
13823 this.lastElementStack = [];
13824 this.nextTokenIndex = 0;
13825 this.stackSize = 0;
13826 }
13827 action() {
13828 // NOOP
13829 }
13830 construct() {
13831 // NOOP
13832 return undefined;
13833 }
13834 parse(input) {
13835 this.resetState();
13836 const tokens = this.lexer.tokenize(input, { mode: 'partial' });
13837 this.tokens = tokens.tokens;
13838 this.wrapper.input = [...this.tokens];
13839 this.mainRule.call(this.wrapper, {});
13840 this.unorderedGroups.clear();
13841 return {
13842 tokens: this.tokens,
13843 elementStack: [...this.lastElementStack],
13844 tokenIndex: this.nextTokenIndex
13845 };
13846 }
13847 rule(rule, impl) {
13848 const ruleMethod = this.wrapper.DEFINE_RULE(withRuleSuffix(rule.name), this.startImplementation(impl).bind(this));
13849 this.allRules.set(rule.name, ruleMethod);
13850 if (rule.entry) {
13851 this.mainRule = ruleMethod;
13852 }
13853 return ruleMethod;
13854 }
13855 resetState() {
13856 this.elementStack = [];
13857 this.lastElementStack = [];
13858 this.nextTokenIndex = 0;
13859 this.stackSize = 0;
13860 }
13861 startImplementation(implementation) {
13862 return (args) => {
13863 const size = this.keepStackSize();
13864 try {
13865 implementation(args);
13866 }
13867 finally {
13868 this.resetStackSize(size);
13869 }
13870 };
13871 }
13872 removeUnexpectedElements() {
13873 this.elementStack.splice(this.stackSize);
13874 }
13875 keepStackSize() {
13876 const size = this.elementStack.length;
13877 this.stackSize = size;
13878 return size;
13879 }
13880 resetStackSize(size) {
13881 this.removeUnexpectedElements();
13882 this.stackSize = size;
13883 }
13884 consume(idx, tokenType, feature) {
13885 this.wrapper.wrapConsume(idx, tokenType);
13886 if (!this.isRecording()) {
13887 this.lastElementStack = [...this.elementStack, feature];
13888 this.nextTokenIndex = this.currIdx + 1;
13889 }
13890 }
13891 subrule(idx, rule, fragment, feature, args) {
13892 this.before(feature);
13893 this.wrapper.wrapSubrule(idx, rule, args);
13894 this.after(feature);
13895 }
13896 before(element) {
13897 if (!this.isRecording()) {
13898 this.elementStack.push(element);
13899 }
13900 }
13901 after(element) {
13902 if (!this.isRecording()) {
13903 const index = this.elementStack.lastIndexOf(element);
13904 if (index >= 0) {
13905 this.elementStack.splice(index);
13906 }
13907 }
13908 }
13909 get currIdx() {
13910 return this.wrapper.currIdx;
13911 }
13912 }
13913 const defaultConfig = {
13914 recoveryEnabled: true,
13915 nodeLocationTracking: 'full',
13916 skipValidations: true,
13917 errorMessageProvider: new LangiumParserErrorMessageProvider()
13918 };
13919 /**
13920 * This class wraps the embedded actions parser of chevrotain and exposes protected methods.
13921 * This way, we can build the `LangiumParser` as a composition.
13922 */
13923 class ChevrotainWrapper extends api/* EmbeddedActionsParser */.nu {
13924 constructor(tokens, config) {
13925 const useDefaultLookahead = config && 'maxLookahead' in config;
13926 super(tokens, Object.assign(Object.assign(Object.assign({}, defaultConfig), { lookaheadStrategy: useDefaultLookahead
13927 ? new api/* LLkLookaheadStrategy */.dV({ maxLookahead: config.maxLookahead })
13928 : new LLStarLookaheadStrategy({
13929 // If validations are skipped, don't log the lookahead warnings
13930 logging: config.skipValidations ? () => { } : undefined
13931 }) }), config));
13932 }
13933 get IS_RECORDING() {
13934 return this.RECORDING_PHASE;
13935 }
13936 DEFINE_RULE(name, impl) {
13937 return this.RULE(name, impl);
13938 }
13939 wrapSelfAnalysis() {
13940 this.performSelfAnalysis();
13941 }
13942 wrapConsume(idx, tokenType) {
13943 return this.consume(idx, tokenType);
13944 }
13945 wrapSubrule(idx, rule, args) {
13946 return this.subrule(idx, rule, {
13947 ARGS: [args]
13948 });
13949 }
13950 wrapOr(idx, choices) {
13951 this.or(idx, choices);
13952 }
13953 wrapOption(idx, callback) {
13954 this.option(idx, callback);
13955 }
13956 wrapMany(idx, callback) {
13957 this.many(idx, callback);
13958 }
13959 wrapAtLeastOne(idx, callback) {
13960 this.atLeastOne(idx, callback);
13961 }
13962 }
13963 //# sourceMappingURL=langium-parser.js.map
13964 // EXTERNAL MODULE: ../node_modules/langium/lib/utils/errors.js
13965 var errors = __webpack_require__(45209);
13966 // EXTERNAL MODULE: ../node_modules/langium/lib/utils/stream.js
13967 var stream = __webpack_require__(99293);
13968 ;// CONCATENATED MODULE: ../node_modules/langium/lib/parser/parser-builder-base.js
13969 /******************************************************************************
13970 * Copyright 2022 TypeFox GmbH
13971 * This program and the accompanying materials are made available under the
13972 * terms of the MIT License, which is available in the project root.
13973 ******************************************************************************/
13974
13975
13976
13977
13978
13979 function createParser(grammar, parser, tokens) {
13980 const parserContext = {
13981 parser,
13982 tokens,
13983 ruleNames: new Map()
13984 };
13985 buildRules(parserContext, grammar);
13986 return parser;
13987 }
13988 function buildRules(parserContext, grammar) {
13989 const reachable = (0,grammar_utils/* getAllReachableRules */.VD)(grammar, false);
13990 const parserRules = (0,stream/* stream */.Vw)(grammar.rules).filter(ast/* isParserRule */.F9).filter(rule => reachable.has(rule));
13991 for (const rule of parserRules) {
13992 const ctx = Object.assign(Object.assign({}, parserContext), { consume: 1, optional: 1, subrule: 1, many: 1, or: 1 });
13993 parserContext.parser.rule(rule, buildElement(ctx, rule.definition));
13994 }
13995 }
13996 function buildElement(ctx, element, ignoreGuard = false) {
13997 let method;
13998 if ((0,ast/* isKeyword */.p1)(element)) {
13999 method = buildKeyword(ctx, element);
14000 }
14001 else if ((0,ast/* isAction */.LG)(element)) {
14002 method = buildAction(ctx, element);
14003 }
14004 else if ((0,ast/* isAssignment */.B7)(element)) {
14005 method = buildElement(ctx, element.terminal);
14006 }
14007 else if ((0,ast/* isCrossReference */.Ki)(element)) {
14008 method = buildCrossReference(ctx, element);
14009 }
14010 else if ((0,ast/* isRuleCall */.t3)(element)) {
14011 method = buildRuleCall(ctx, element);
14012 }
14013 else if ((0,ast/* isAlternatives */.MZ)(element)) {
14014 method = buildAlternatives(ctx, element);
14015 }
14016 else if ((0,ast/* isUnorderedGroup */.W1)(element)) {
14017 method = buildUnorderedGroup(ctx, element);
14018 }
14019 else if ((0,ast/* isGroup */.ty)(element)) {
14020 method = buildGroup(ctx, element);
14021 }
14022 else if ((0,ast/* isEndOfFile */.rT)(element)) {
14023 const idx = ctx.consume++;
14024 method = () => ctx.parser.consume(idx, api/* EOF */.sd, element);
14025 }
14026 else {
14027 throw new errors/* ErrorWithLocation */.h(element.$cstNode, `Unexpected element type: ${element.$type}`);
14028 }
14029 return wrap(ctx, ignoreGuard ? undefined : getGuardCondition(element), method, element.cardinality);
14030 }
14031 function buildAction(ctx, action) {
14032 const actionType = (0,grammar_utils/* getTypeName */.z$)(action);
14033 return () => ctx.parser.action(actionType, action);
14034 }
14035 function buildRuleCall(ctx, ruleCall) {
14036 const rule = ruleCall.rule.ref;
14037 if ((0,ast/* isParserRule */.F9)(rule)) {
14038 const idx = ctx.subrule++;
14039 const fragment = rule.fragment;
14040 const predicate = ruleCall.arguments.length > 0 ? buildRuleCallPredicate(rule, ruleCall.arguments) : () => ({});
14041 return (args) => ctx.parser.subrule(idx, getRule(ctx, rule), fragment, ruleCall, predicate(args));
14042 }
14043 else if ((0,ast/* isTerminalRule */.MS)(rule)) {
14044 const idx = ctx.consume++;
14045 const method = getToken(ctx, rule.name);
14046 return () => ctx.parser.consume(idx, method, ruleCall);
14047 }
14048 else if (!rule) {
14049 throw new errors/* ErrorWithLocation */.h(ruleCall.$cstNode, `Undefined rule: ${ruleCall.rule.$refText}`);
14050 }
14051 else {
14052 (0,errors/* assertUnreachable */.U)(rule);
14053 }
14054 }
14055 function buildRuleCallPredicate(rule, namedArgs) {
14056 const predicates = namedArgs.map(e => buildPredicate(e.value));
14057 return (args) => {
14058 const ruleArgs = {};
14059 for (let i = 0; i < predicates.length; i++) {
14060 const ruleTarget = rule.parameters[i];
14061 const predicate = predicates[i];
14062 ruleArgs[ruleTarget.name] = predicate(args);
14063 }
14064 return ruleArgs;
14065 };
14066 }
14067 function buildPredicate(condition) {
14068 if ((0,ast/* isDisjunction */.F8)(condition)) {
14069 const left = buildPredicate(condition.left);
14070 const right = buildPredicate(condition.right);
14071 return (args) => (left(args) || right(args));
14072 }
14073 else if ((0,ast/* isConjunction */.TB)(condition)) {
14074 const left = buildPredicate(condition.left);
14075 const right = buildPredicate(condition.right);
14076 return (args) => (left(args) && right(args));
14077 }
14078 else if ((0,ast/* isNegation */.Ii)(condition)) {
14079 const value = buildPredicate(condition.value);
14080 return (args) => !value(args);
14081 }
14082 else if ((0,ast/* isParameterReference */.yW)(condition)) {
14083 const name = condition.parameter.ref.name;
14084 return (args) => args !== undefined && args[name] === true;
14085 }
14086 else if ((0,ast/* isBooleanLiteral */.L)(condition)) {
14087 const value = Boolean(condition.true);
14088 return () => value;
14089 }
14090 (0,errors/* assertUnreachable */.U)(condition);
14091 }
14092 function buildAlternatives(ctx, alternatives) {
14093 if (alternatives.elements.length === 1) {
14094 return buildElement(ctx, alternatives.elements[0]);
14095 }
14096 else {
14097 const methods = [];
14098 for (const element of alternatives.elements) {
14099 const predicatedMethod = {
14100 // Since we handle the guard condition in the alternative already
14101 // We can ignore the group guard condition inside
14102 ALT: buildElement(ctx, element, true)
14103 };
14104 const guard = getGuardCondition(element);
14105 if (guard) {
14106 predicatedMethod.GATE = buildPredicate(guard);
14107 }
14108 methods.push(predicatedMethod);
14109 }
14110 const idx = ctx.or++;
14111 return (args) => ctx.parser.alternatives(idx, methods.map(method => {
14112 const alt = {
14113 ALT: () => method.ALT(args)
14114 };
14115 const gate = method.GATE;
14116 if (gate) {
14117 alt.GATE = () => gate(args);
14118 }
14119 return alt;
14120 }));
14121 }
14122 }
14123 function buildUnorderedGroup(ctx, group) {
14124 if (group.elements.length === 1) {
14125 return buildElement(ctx, group.elements[0]);
14126 }
14127 const methods = [];
14128 for (const element of group.elements) {
14129 const predicatedMethod = {
14130 // Since we handle the guard condition in the alternative already
14131 // We can ignore the group guard condition inside
14132 ALT: buildElement(ctx, element, true)
14133 };
14134 const guard = getGuardCondition(element);
14135 if (guard) {
14136 predicatedMethod.GATE = buildPredicate(guard);
14137 }
14138 methods.push(predicatedMethod);
14139 }
14140 const orIdx = ctx.or++;
14141 const idFunc = (groupIdx, lParser) => {
14142 const stackId = lParser.getRuleStack().join('-');
14143 return `uGroup_${groupIdx}_${stackId}`;
14144 };
14145 const alternatives = (args) => ctx.parser.alternatives(orIdx, methods.map((method, idx) => {
14146 const alt = { ALT: () => true };
14147 const parser = ctx.parser;
14148 alt.ALT = () => {
14149 method.ALT(args);
14150 if (!parser.isRecording()) {
14151 const key = idFunc(orIdx, parser);
14152 if (!parser.unorderedGroups.get(key)) {
14153 // init after clear state
14154 parser.unorderedGroups.set(key, []);
14155 }
14156 const groupState = parser.unorderedGroups.get(key);
14157 if (typeof (groupState === null || groupState === void 0 ? void 0 : groupState[idx]) === 'undefined') {
14158 // Not accessed yet
14159 groupState[idx] = true;
14160 }
14161 }
14162 };
14163 const gate = method.GATE;
14164 if (gate) {
14165 alt.GATE = () => gate(args);
14166 }
14167 else {
14168 alt.GATE = () => {
14169 const trackedAlternatives = parser.unorderedGroups.get(idFunc(orIdx, parser));
14170 const allow = !(trackedAlternatives === null || trackedAlternatives === void 0 ? void 0 : trackedAlternatives[idx]);
14171 return allow;
14172 };
14173 }
14174 return alt;
14175 }));
14176 const wrapped = wrap(ctx, getGuardCondition(group), alternatives, '*');
14177 return (args) => {
14178 wrapped(args);
14179 if (!ctx.parser.isRecording()) {
14180 ctx.parser.unorderedGroups.delete(idFunc(orIdx, ctx.parser));
14181 }
14182 };
14183 }
14184 function buildGroup(ctx, group) {
14185 const methods = group.elements.map(e => buildElement(ctx, e));
14186 return (args) => methods.forEach(method => method(args));
14187 }
14188 function getGuardCondition(element) {
14189 if ((0,ast/* isGroup */.ty)(element)) {
14190 return element.guardCondition;
14191 }
14192 return undefined;
14193 }
14194 function buildCrossReference(ctx, crossRef, terminal = crossRef.terminal) {
14195 if (!terminal) {
14196 if (!crossRef.type.ref) {
14197 throw new Error('Could not resolve reference to type: ' + crossRef.type.$refText);
14198 }
14199 const assignment = (0,grammar_utils/* findNameAssignment */.ib)(crossRef.type.ref);
14200 const assignTerminal = assignment === null || assignment === void 0 ? void 0 : assignment.terminal;
14201 if (!assignTerminal) {
14202 throw new Error('Could not find name assignment for type: ' + (0,grammar_utils/* getTypeName */.z$)(crossRef.type.ref));
14203 }
14204 return buildCrossReference(ctx, crossRef, assignTerminal);
14205 }
14206 else if ((0,ast/* isRuleCall */.t3)(terminal) && (0,ast/* isParserRule */.F9)(terminal.rule.ref)) {
14207 // The terminal is a data type rule here. Everything else will result in a validation error.
14208 const rule = terminal.rule.ref;
14209 const idx = ctx.subrule++;
14210 return (args) => ctx.parser.subrule(idx, getRule(ctx, rule), false, crossRef, args);
14211 }
14212 else if ((0,ast/* isRuleCall */.t3)(terminal) && (0,ast/* isTerminalRule */.MS)(terminal.rule.ref)) {
14213 const idx = ctx.consume++;
14214 const terminalRule = getToken(ctx, terminal.rule.ref.name);
14215 return () => ctx.parser.consume(idx, terminalRule, crossRef);
14216 }
14217 else if ((0,ast/* isKeyword */.p1)(terminal)) {
14218 const idx = ctx.consume++;
14219 const keyword = getToken(ctx, terminal.value);
14220 return () => ctx.parser.consume(idx, keyword, crossRef);
14221 }
14222 else {
14223 throw new Error('Could not build cross reference parser');
14224 }
14225 }
14226 function buildKeyword(ctx, keyword) {
14227 const idx = ctx.consume++;
14228 const token = ctx.tokens[keyword.value];
14229 if (!token) {
14230 throw new Error('Could not find token for keyword: ' + keyword.value);
14231 }
14232 return () => ctx.parser.consume(idx, token, keyword);
14233 }
14234 function wrap(ctx, guard, method, cardinality) {
14235 const gate = guard && buildPredicate(guard);
14236 if (!cardinality) {
14237 if (gate) {
14238 const idx = ctx.or++;
14239 return (args) => ctx.parser.alternatives(idx, [
14240 {
14241 ALT: () => method(args),
14242 GATE: () => gate(args)
14243 },
14244 {
14245 ALT: (0,api/* EMPTY_ALT */._o)(),
14246 GATE: () => !gate(args)
14247 }
14248 ]);
14249 }
14250 else {
14251 return method;
14252 }
14253 }
14254 if (cardinality === '*') {
14255 const idx = ctx.many++;
14256 return (args) => ctx.parser.many(idx, {
14257 DEF: () => method(args),
14258 GATE: gate ? () => gate(args) : undefined
14259 });
14260 }
14261 else if (cardinality === '+') {
14262 const idx = ctx.many++;
14263 if (gate) {
14264 const orIdx = ctx.or++;
14265 // In the case of a guard condition for the `+` group
14266 // We combine it with an empty alternative
14267 // If the condition returns true, it needs to parse at least a single iteration
14268 // If its false, it is not allowed to parse anything
14269 return (args) => ctx.parser.alternatives(orIdx, [
14270 {
14271 ALT: () => ctx.parser.atLeastOne(idx, {
14272 DEF: () => method(args)
14273 }),
14274 GATE: () => gate(args)
14275 },
14276 {
14277 ALT: (0,api/* EMPTY_ALT */._o)(),
14278 GATE: () => !gate(args)
14279 }
14280 ]);
14281 }
14282 else {
14283 return (args) => ctx.parser.atLeastOne(idx, {
14284 DEF: () => method(args),
14285 });
14286 }
14287 }
14288 else if (cardinality === '?') {
14289 const idx = ctx.optional++;
14290 return (args) => ctx.parser.optional(idx, {
14291 DEF: () => method(args),
14292 GATE: gate ? () => gate(args) : undefined
14293 });
14294 }
14295 else {
14296 (0,errors/* assertUnreachable */.U)(cardinality);
14297 }
14298 }
14299 function getRule(ctx, element) {
14300 const name = getRuleName(ctx, element);
14301 const rule = ctx.parser.getRule(name);
14302 if (!rule)
14303 throw new Error(`Rule "${name}" not found."`);
14304 return rule;
14305 }
14306 function getRuleName(ctx, element) {
14307 if ((0,ast/* isParserRule */.F9)(element)) {
14308 return element.name;
14309 }
14310 else if (ctx.ruleNames.has(element)) {
14311 return ctx.ruleNames.get(element);
14312 }
14313 else {
14314 let item = element;
14315 let parent = item.$container;
14316 let ruleName = element.$type;
14317 while (!(0,ast/* isParserRule */.F9)(parent)) {
14318 if ((0,ast/* isGroup */.ty)(parent) || (0,ast/* isAlternatives */.MZ)(parent) || (0,ast/* isUnorderedGroup */.W1)(parent)) {
14319 const index = parent.elements.indexOf(item);
14320 ruleName = index.toString() + ':' + ruleName;
14321 }
14322 item = parent;
14323 parent = parent.$container;
14324 }
14325 const rule = parent;
14326 ruleName = rule.name + ':' + ruleName;
14327 ctx.ruleNames.set(element, ruleName);
14328 return ruleName;
14329 }
14330 }
14331 function getToken(ctx, name) {
14332 const token = ctx.tokens[name];
14333 if (!token)
14334 throw new Error(`Token "${name}" not found."`);
14335 return token;
14336 }
14337 //# sourceMappingURL=parser-builder-base.js.map
14338 ;// CONCATENATED MODULE: ../node_modules/langium/lib/parser/completion-parser-builder.js
14339 /******************************************************************************
14340 * Copyright 2022 TypeFox GmbH
14341 * This program and the accompanying materials are made available under the
14342 * terms of the MIT License, which is available in the project root.
14343 ******************************************************************************/
14344
14345
14346 function createCompletionParser(services) {
14347 const grammar = services.Grammar;
14348 const lexer = services.parser.Lexer;
14349 const parser = new LangiumCompletionParser(services);
14350 createParser(grammar, parser, lexer.definition);
14351 parser.finalize();
14352 return parser;
14353 }
14354 //# sourceMappingURL=completion-parser-builder.js.map
14355 ;// CONCATENATED MODULE: ../node_modules/langium/lib/parser/langium-parser-builder.js
14356 /******************************************************************************
14357 * Copyright 2021 TypeFox GmbH
14358 * This program and the accompanying materials are made available under the
14359 * terms of the MIT License, which is available in the project root.
14360 ******************************************************************************/
14361
14362
14363 /**
14364 * Create and finalize a Langium parser. The parser rules are derived from the grammar, which is
14365 * available at `services.Grammar`.
14366 */
14367 function createLangiumParser(services) {
14368 const parser = prepareLangiumParser(services);
14369 parser.finalize();
14370 return parser;
14371 }
14372 /**
14373 * Create a Langium parser without finalizing it. This is used to extract more detailed error
14374 * information when the parser is initially validated.
14375 */
14376 function prepareLangiumParser(services) {
14377 const grammar = services.Grammar;
14378 const lexer = services.parser.Lexer;
14379 const parser = new LangiumParser(services);
14380 return createParser(grammar, parser, lexer.definition);
14381 }
14382 //# sourceMappingURL=langium-parser-builder.js.map
14383 // EXTERNAL MODULE: ../node_modules/langium/lib/parser/token-builder.js
14384 var token_builder = __webpack_require__(35481);
14385 // EXTERNAL MODULE: ../node_modules/langium/lib/parser/value-converter.js
14386 var value_converter = __webpack_require__(46174);
14387 // EXTERNAL MODULE: ../node_modules/vscode-jsonrpc/lib/common/cancellation.js
14388 var cancellation = __webpack_require__(97770);
14389 // EXTERNAL MODULE: ../node_modules/langium/lib/syntax-tree.js
14390 var syntax_tree = __webpack_require__(91303);
14391 ;// CONCATENATED MODULE: ../node_modules/langium/lib/utils/promise-utils.js
14392 /******************************************************************************
14393 * Copyright 2021 TypeFox GmbH
14394 * This program and the accompanying materials are made available under the
14395 * terms of the MIT License, which is available in the project root.
14396 ******************************************************************************/
14397
14398 /**
14399 * Delays the execution of the current code to the next tick of the event loop.
14400 * Don't call this method directly in a tight loop to prevent too many promises from being created.
14401 */
14402 function delayNextTick() {
14403 return new Promise(resolve => {
14404 // In case we are running in a non-node environment, `setImmediate` isn't available.
14405 // Using `setTimeout` of the browser API accomplishes the same result.
14406 if (typeof setImmediate === 'undefined') {
14407 setTimeout(resolve, 0);
14408 }
14409 else {
14410 setImmediate(resolve);
14411 }
14412 });
14413 }
14414 let lastTick = 0;
14415 let globalInterruptionPeriod = 10;
14416 /**
14417 * Reset the global interruption period and create a cancellation token source.
14418 */
14419 function startCancelableOperation() {
14420 lastTick = performance.now();
14421 return new cancellation.CancellationTokenSource();
14422 }
14423 /**
14424 * Change the period duration for `interruptAndCheck` to the given number of milliseconds.
14425 * The default value is 10ms.
14426 */
14427 function setInterruptionPeriod(period) {
14428 globalInterruptionPeriod = period;
14429 }
14430 /**
14431 * This symbol may be thrown in an asynchronous context by any Langium service that receives
14432 * a `CancellationToken`. This means that the promise returned by such a service is rejected with
14433 * this symbol as rejection reason.
14434 */
14435 const promise_utils_OperationCancelled = Symbol('OperationCancelled');
14436 /**
14437 * Use this in a `catch` block to check whether the thrown object indicates that the operation
14438 * has been cancelled.
14439 */
14440 function isOperationCancelled(err) {
14441 return err === promise_utils_OperationCancelled;
14442 }
14443 /**
14444 * This function does two things:
14445 * 1. Check the elapsed time since the last call to this function or to `startCancelableOperation`. If the predefined
14446 * period (configured with `setInterruptionPeriod`) is exceeded, execution is delayed with `delayNextTick`.
14447 * 2. If the predefined period is not met yet or execution is resumed after an interruption, the given cancellation
14448 * token is checked, and if cancellation is requested, `OperationCanceled` is thrown.
14449 *
14450 * All services in Langium that receive a `CancellationToken` may potentially call this function, so the
14451 * `CancellationToken` must be caught (with an `async` try-catch block or a `catch` callback attached to
14452 * the promise) to avoid that event being exposed as an error.
14453 */
14454 async function interruptAndCheck(token) {
14455 if (token === cancellation.CancellationToken.None) {
14456 // Early exit in case cancellation was disabled by the caller
14457 return;
14458 }
14459 const current = performance.now();
14460 if (current - lastTick >= globalInterruptionPeriod) {
14461 lastTick = current;
14462 await delayNextTick();
14463 // prevent calling delayNextTick every iteration of loop
14464 // where delayNextTick takes up the majority or all of the
14465 // globalInterruptionPeriod itself
14466 lastTick = performance.now();
14467 }
14468 if (token.isCancellationRequested) {
14469 throw promise_utils_OperationCancelled;
14470 }
14471 }
14472 /**
14473 * Simple implementation of the deferred pattern.
14474 * An object that exposes a promise and functions to resolve and reject it.
14475 */
14476 class promise_utils_Deferred {
14477 constructor() {
14478 this.promise = new Promise((resolve, reject) => {
14479 this.resolve = (arg) => {
14480 resolve(arg);
14481 return this;
14482 };
14483 this.reject = (err) => {
14484 reject(err);
14485 return this;
14486 };
14487 });
14488 }
14489 }
14490 //# sourceMappingURL=promise-utils.js.map
14491 ;// CONCATENATED MODULE: ../node_modules/vscode-languageserver-textdocument/lib/esm/main.js
14492 /* --------------------------------------------------------------------------------------------
14493 * Copyright (c) Microsoft Corporation. All rights reserved.
14494 * Licensed under the MIT License. See License.txt in the project root for license information.
14495 * ------------------------------------------------------------------------------------------ */
14496
14497 class main_FullTextDocument {
14498 constructor(uri, languageId, version, content) {
14499 this._uri = uri;
14500 this._languageId = languageId;
14501 this._version = version;
14502 this._content = content;
14503 this._lineOffsets = undefined;
14504 }
14505 get uri() {
14506 return this._uri;
14507 }
14508 get languageId() {
14509 return this._languageId;
14510 }
14511 get version() {
14512 return this._version;
14513 }
14514 getText(range) {
14515 if (range) {
14516 const start = this.offsetAt(range.start);
14517 const end = this.offsetAt(range.end);
14518 return this._content.substring(start, end);
14519 }
14520 return this._content;
14521 }
14522 update(changes, version) {
14523 for (const change of changes) {
14524 if (main_FullTextDocument.isIncremental(change)) {
14525 // makes sure start is before end
14526 const range = getWellformedRange(change.range);
14527 // update content
14528 const startOffset = this.offsetAt(range.start);
14529 const endOffset = this.offsetAt(range.end);
14530 this._content = this._content.substring(0, startOffset) + change.text + this._content.substring(endOffset, this._content.length);
14531 // update the offsets
14532 const startLine = Math.max(range.start.line, 0);
14533 const endLine = Math.max(range.end.line, 0);
14534 let lineOffsets = this._lineOffsets;
14535 const addedLineOffsets = computeLineOffsets(change.text, false, startOffset);
14536 if (endLine - startLine === addedLineOffsets.length) {
14537 for (let i = 0, len = addedLineOffsets.length; i < len; i++) {
14538 lineOffsets[i + startLine + 1] = addedLineOffsets[i];
14539 }
14540 }
14541 else {
14542 if (addedLineOffsets.length < 10000) {
14543 lineOffsets.splice(startLine + 1, endLine - startLine, ...addedLineOffsets);
14544 }
14545 else { // avoid too many arguments for splice
14546 this._lineOffsets = lineOffsets = lineOffsets.slice(0, startLine + 1).concat(addedLineOffsets, lineOffsets.slice(endLine + 1));
14547 }
14548 }
14549 const diff = change.text.length - (endOffset - startOffset);
14550 if (diff !== 0) {
14551 for (let i = startLine + 1 + addedLineOffsets.length, len = lineOffsets.length; i < len; i++) {
14552 lineOffsets[i] = lineOffsets[i] + diff;
14553 }
14554 }
14555 }
14556 else if (main_FullTextDocument.isFull(change)) {
14557 this._content = change.text;
14558 this._lineOffsets = undefined;
14559 }
14560 else {
14561 throw new Error('Unknown change event received');
14562 }
14563 }
14564 this._version = version;
14565 }
14566 getLineOffsets() {
14567 if (this._lineOffsets === undefined) {
14568 this._lineOffsets = computeLineOffsets(this._content, true);
14569 }
14570 return this._lineOffsets;
14571 }
14572 positionAt(offset) {
14573 offset = Math.max(Math.min(offset, this._content.length), 0);
14574 const lineOffsets = this.getLineOffsets();
14575 let low = 0, high = lineOffsets.length;
14576 if (high === 0) {
14577 return { line: 0, character: offset };
14578 }
14579 while (low < high) {
14580 const mid = Math.floor((low + high) / 2);
14581 if (lineOffsets[mid] > offset) {
14582 high = mid;
14583 }
14584 else {
14585 low = mid + 1;
14586 }
14587 }
14588 // low is the least x for which the line offset is larger than the current offset
14589 // or array.length if no line offset is larger than the current offset
14590 const line = low - 1;
14591 offset = this.ensureBeforeEOL(offset, lineOffsets[line]);
14592 return { line, character: offset - lineOffsets[line] };
14593 }
14594 offsetAt(position) {
14595 const lineOffsets = this.getLineOffsets();
14596 if (position.line >= lineOffsets.length) {
14597 return this._content.length;
14598 }
14599 else if (position.line < 0) {
14600 return 0;
14601 }
14602 const lineOffset = lineOffsets[position.line];
14603 if (position.character <= 0) {
14604 return lineOffset;
14605 }
14606 const nextLineOffset = (position.line + 1 < lineOffsets.length) ? lineOffsets[position.line + 1] : this._content.length;
14607 const offset = Math.min(lineOffset + position.character, nextLineOffset);
14608 return this.ensureBeforeEOL(offset, lineOffset);
14609 }
14610 ensureBeforeEOL(offset, lineOffset) {
14611 while (offset > lineOffset && isEOL(this._content.charCodeAt(offset - 1))) {
14612 offset--;
14613 }
14614 return offset;
14615 }
14616 get lineCount() {
14617 return this.getLineOffsets().length;
14618 }
14619 static isIncremental(event) {
14620 const candidate = event;
14621 return candidate !== undefined && candidate !== null &&
14622 typeof candidate.text === 'string' && candidate.range !== undefined &&
14623 (candidate.rangeLength === undefined || typeof candidate.rangeLength === 'number');
14624 }
14625 static isFull(event) {
14626 const candidate = event;
14627 return candidate !== undefined && candidate !== null &&
14628 typeof candidate.text === 'string' && candidate.range === undefined && candidate.rangeLength === undefined;
14629 }
14630 }
14631 var main_TextDocument;
14632 (function (TextDocument) {
14633 /**
14634 * Creates a new text document.
14635 *
14636 * @param uri The document's uri.
14637 * @param languageId The document's language Id.
14638 * @param version The document's initial version number.
14639 * @param content The document's content.
14640 */
14641 function create(uri, languageId, version, content) {
14642 return new main_FullTextDocument(uri, languageId, version, content);
14643 }
14644 TextDocument.create = create;
14645 /**
14646 * Updates a TextDocument by modifying its content.
14647 *
14648 * @param document the document to update. Only documents created by TextDocument.create are valid inputs.
14649 * @param changes the changes to apply to the document.
14650 * @param version the changes version for the document.
14651 * @returns The updated TextDocument. Note: That's the same document instance passed in as first parameter.
14652 *
14653 */
14654 function update(document, changes, version) {
14655 if (document instanceof main_FullTextDocument) {
14656 document.update(changes, version);
14657 return document;
14658 }
14659 else {
14660 throw new Error('TextDocument.update: document must be created by TextDocument.create');
14661 }
14662 }
14663 TextDocument.update = update;
14664 function applyEdits(document, edits) {
14665 const text = document.getText();
14666 const sortedEdits = mergeSort(edits.map(getWellformedEdit), (a, b) => {
14667 const diff = a.range.start.line - b.range.start.line;
14668 if (diff === 0) {
14669 return a.range.start.character - b.range.start.character;
14670 }
14671 return diff;
14672 });
14673 let lastModifiedOffset = 0;
14674 const spans = [];
14675 for (const e of sortedEdits) {
14676 const startOffset = document.offsetAt(e.range.start);
14677 if (startOffset < lastModifiedOffset) {
14678 throw new Error('Overlapping edit');
14679 }
14680 else if (startOffset > lastModifiedOffset) {
14681 spans.push(text.substring(lastModifiedOffset, startOffset));
14682 }
14683 if (e.newText.length) {
14684 spans.push(e.newText);
14685 }
14686 lastModifiedOffset = document.offsetAt(e.range.end);
14687 }
14688 spans.push(text.substr(lastModifiedOffset));
14689 return spans.join('');
14690 }
14691 TextDocument.applyEdits = applyEdits;
14692 })(main_TextDocument || (main_TextDocument = {}));
14693 function mergeSort(data, compare) {
14694 if (data.length <= 1) {
14695 // sorted
14696 return data;
14697 }
14698 const p = (data.length / 2) | 0;
14699 const left = data.slice(0, p);
14700 const right = data.slice(p);
14701 mergeSort(left, compare);
14702 mergeSort(right, compare);
14703 let leftIdx = 0;
14704 let rightIdx = 0;
14705 let i = 0;
14706 while (leftIdx < left.length && rightIdx < right.length) {
14707 const ret = compare(left[leftIdx], right[rightIdx]);
14708 if (ret <= 0) {
14709 // smaller_equal -> take left to preserve order
14710 data[i++] = left[leftIdx++];
14711 }
14712 else {
14713 // greater -> take right
14714 data[i++] = right[rightIdx++];
14715 }
14716 }
14717 while (leftIdx < left.length) {
14718 data[i++] = left[leftIdx++];
14719 }
14720 while (rightIdx < right.length) {
14721 data[i++] = right[rightIdx++];
14722 }
14723 return data;
14724 }
14725 function computeLineOffsets(text, isAtLineStart, textOffset = 0) {
14726 const result = isAtLineStart ? [textOffset] : [];
14727 for (let i = 0; i < text.length; i++) {
14728 const ch = text.charCodeAt(i);
14729 if (isEOL(ch)) {
14730 if (ch === 13 /* CharCode.CarriageReturn */ && i + 1 < text.length && text.charCodeAt(i + 1) === 10 /* CharCode.LineFeed */) {
14731 i++;
14732 }
14733 result.push(textOffset + i + 1);
14734 }
14735 }
14736 return result;
14737 }
14738 function isEOL(char) {
14739 return char === 13 /* CharCode.CarriageReturn */ || char === 10 /* CharCode.LineFeed */;
14740 }
14741 function getWellformedRange(range) {
14742 const start = range.start;
14743 const end = range.end;
14744 if (start.line > end.line || (start.line === end.line && start.character > end.character)) {
14745 return { start: end, end: start };
14746 }
14747 return range;
14748 }
14749 function getWellformedEdit(textEdit) {
14750 const range = getWellformedRange(textEdit.range);
14751 if (range !== textEdit.range) {
14752 return { newText: textEdit.newText, range };
14753 }
14754 return textEdit;
14755 }
14756
14757 // EXTERNAL MODULE: ../node_modules/vscode-uri/lib/esm/index.mjs
14758 var esm = __webpack_require__(37943);
14759 ;// CONCATENATED MODULE: ../node_modules/langium/lib/workspace/documents.js
14760 /******************************************************************************
14761 * Copyright 2021 TypeFox GmbH
14762 * This program and the accompanying materials are made available under the
14763 * terms of the MIT License, which is available in the project root.
14764 ******************************************************************************/
14765 /**
14766 * Re-export 'TextDocument' from 'vscode-languageserver-textdocument' for convenience,
14767 * including both type _and_ symbol (namespace), as we here and there also refer to the symbol,
14768 * the overhead is very small, just a few kilobytes.
14769 * Everything else of that package (at the time contributing) is also defined
14770 * in 'vscode-languageserver-protocol' or 'vscode-languageserver-types'.
14771 */
14772
14773
14774
14775
14776
14777 /**
14778 * A document is subject to several phases that are run in predefined order. Any state value implies that
14779 * smaller state values are finished as well.
14780 */
14781 var DocumentState;
14782 (function (DocumentState) {
14783 /**
14784 * The text content has changed and needs to be parsed again. The AST held by this outdated
14785 * document instance is no longer valid.
14786 */
14787 DocumentState[DocumentState["Changed"] = 0] = "Changed";
14788 /**
14789 * An AST has been created from the text content. The document structure can be traversed,
14790 * but cross-references cannot be resolved yet. If necessary, the structure can be manipulated
14791 * at this stage as a preprocessing step.
14792 */
14793 DocumentState[DocumentState["Parsed"] = 1] = "Parsed";
14794 /**
14795 * The `IndexManager` service has processed AST nodes of this document. This means the
14796 * exported symbols are available in the global scope and can be resolved from other documents.
14797 */
14798 DocumentState[DocumentState["IndexedContent"] = 2] = "IndexedContent";
14799 /**
14800 * The `ScopeComputation` service has processed this document. This means the local symbols
14801 * are stored in a MultiMap so they can be looked up by the `ScopeProvider` service.
14802 * Once a document has reached this state, you may follow every reference - it will lazily
14803 * resolve its `ref` property and yield either the target AST node or `undefined` in case
14804 * the target is not in scope.
14805 */
14806 DocumentState[DocumentState["ComputedScopes"] = 3] = "ComputedScopes";
14807 /**
14808 * The `Linker` service has processed this document. All outgoing references have been
14809 * resolved or marked as erroneous.
14810 */
14811 DocumentState[DocumentState["Linked"] = 4] = "Linked";
14812 /**
14813 * The `IndexManager` service has processed AST node references of this document. This is
14814 * necessary to determine which documents are affected by a change in one of the workspace
14815 * documents.
14816 */
14817 DocumentState[DocumentState["IndexedReferences"] = 5] = "IndexedReferences";
14818 /**
14819 * The `DocumentValidator` service has processed this document. The language server listens
14820 * to the results of this phase and sends diagnostics to the client.
14821 */
14822 DocumentState[DocumentState["Validated"] = 6] = "Validated";
14823 })(DocumentState || (DocumentState = {}));
14824 class DefaultLangiumDocumentFactory {
14825 constructor(services) {
14826 this.serviceRegistry = services.ServiceRegistry;
14827 this.textDocuments = services.workspace.TextDocuments;
14828 this.fileSystemProvider = services.workspace.FileSystemProvider;
14829 }
14830 async fromUri(uri, cancellationToken = cancellation.CancellationToken.None) {
14831 const content = await this.fileSystemProvider.readFile(uri);
14832 return this.createAsync(uri, content, cancellationToken);
14833 }
14834 fromTextDocument(textDocument, uri, token) {
14835 uri = uri !== null && uri !== void 0 ? uri : esm/* URI */.o.parse(textDocument.uri);
14836 if (cancellation.CancellationToken.is(token)) {
14837 return this.createAsync(uri, textDocument, token);
14838 }
14839 else {
14840 return this.create(uri, textDocument, token);
14841 }
14842 }
14843 fromString(text, uri, token) {
14844 if (cancellation.CancellationToken.is(token)) {
14845 return this.createAsync(uri, text, token);
14846 }
14847 else {
14848 return this.create(uri, text, token);
14849 }
14850 }
14851 fromModel(model, uri) {
14852 return this.create(uri, { $model: model });
14853 }
14854 create(uri, content, options) {
14855 if (typeof content === 'string') {
14856 const parseResult = this.parse(uri, content, options);
14857 return this.createLangiumDocument(parseResult, uri, undefined, content);
14858 }
14859 else if ('$model' in content) {
14860 const parseResult = { value: content.$model, parserErrors: [], lexerErrors: [] };
14861 return this.createLangiumDocument(parseResult, uri);
14862 }
14863 else {
14864 const parseResult = this.parse(uri, content.getText(), options);
14865 return this.createLangiumDocument(parseResult, uri, content);
14866 }
14867 }
14868 async createAsync(uri, content, cancelToken) {
14869 if (typeof content === 'string') {
14870 const parseResult = await this.parseAsync(uri, content, cancelToken);
14871 return this.createLangiumDocument(parseResult, uri, undefined, content);
14872 }
14873 else {
14874 const parseResult = await this.parseAsync(uri, content.getText(), cancelToken);
14875 return this.createLangiumDocument(parseResult, uri, content);
14876 }
14877 }
14878 /**
14879 * Create a LangiumDocument from a given parse result.
14880 *
14881 * A TextDocument is created on demand if it is not provided as argument here. Usually this
14882 * should not be necessary because the main purpose of the TextDocument is to convert between
14883 * text ranges and offsets, which is done solely in LSP request handling.
14884 *
14885 * With the introduction of {@link update} below this method is supposed to be mainly called
14886 * during workspace initialization and on addition/recognition of new files, while changes in
14887 * existing documents are processed via {@link update}.
14888 */
14889 createLangiumDocument(parseResult, uri, textDocument, text) {
14890 let document;
14891 if (textDocument) {
14892 document = {
14893 parseResult,
14894 uri,
14895 state: DocumentState.Parsed,
14896 references: [],
14897 textDocument
14898 };
14899 }
14900 else {
14901 const textDocumentGetter = this.createTextDocumentGetter(uri, text);
14902 document = {
14903 parseResult,
14904 uri,
14905 state: DocumentState.Parsed,
14906 references: [],
14907 get textDocument() {
14908 return textDocumentGetter();
14909 }
14910 };
14911 }
14912 parseResult.value.$document = document;
14913 return document;
14914 }
14915 async update(document, cancellationToken) {
14916 var _a, _b;
14917 // The CST full text property contains the original text that was used to create the AST.
14918 const oldText = (_a = document.parseResult.value.$cstNode) === null || _a === void 0 ? void 0 : _a.root.fullText;
14919 const textDocument = (_b = this.textDocuments) === null || _b === void 0 ? void 0 : _b.get(document.uri.toString());
14920 const text = textDocument ? textDocument.getText() : await this.fileSystemProvider.readFile(document.uri);
14921 if (textDocument) {
14922 Object.defineProperty(document, 'textDocument', {
14923 value: textDocument
14924 });
14925 }
14926 else {
14927 const textDocumentGetter = this.createTextDocumentGetter(document.uri, text);
14928 Object.defineProperty(document, 'textDocument', {
14929 get: textDocumentGetter
14930 });
14931 }
14932 // Some of these documents can be pretty large, so parsing them again can be quite expensive.
14933 // Therefore, we only parse if the text has actually changed.
14934 if (oldText !== text) {
14935 document.parseResult = await this.parseAsync(document.uri, text, cancellationToken);
14936 document.parseResult.value.$document = document;
14937 }
14938 document.state = DocumentState.Parsed;
14939 return document;
14940 }
14941 parse(uri, text, options) {
14942 const services = this.serviceRegistry.getServices(uri);
14943 return services.parser.LangiumParser.parse(text, options);
14944 }
14945 parseAsync(uri, text, cancellationToken) {
14946 const services = this.serviceRegistry.getServices(uri);
14947 return services.parser.AsyncParser.parse(text, cancellationToken);
14948 }
14949 createTextDocumentGetter(uri, text) {
14950 const serviceRegistry = this.serviceRegistry;
14951 let textDoc = undefined;
14952 return () => {
14953 return textDoc !== null && textDoc !== void 0 ? textDoc : (textDoc = main_TextDocument.create(uri.toString(), serviceRegistry.getServices(uri).LanguageMetaData.languageId, 0, text !== null && text !== void 0 ? text : ''));
14954 };
14955 }
14956 }
14957 class DefaultLangiumDocuments {
14958 constructor(services) {
14959 this.documentMap = new Map();
14960 this.langiumDocumentFactory = services.workspace.LangiumDocumentFactory;
14961 this.serviceRegistry = services.ServiceRegistry;
14962 }
14963 get all() {
14964 return (0,stream/* stream */.Vw)(this.documentMap.values());
14965 }
14966 addDocument(document) {
14967 const uriString = document.uri.toString();
14968 if (this.documentMap.has(uriString)) {
14969 throw new Error(`A document with the URI '${uriString}' is already present.`);
14970 }
14971 this.documentMap.set(uriString, document);
14972 }
14973 getDocument(uri) {
14974 const uriString = uri.toString();
14975 return this.documentMap.get(uriString);
14976 }
14977 async getOrCreateDocument(uri, cancellationToken) {
14978 let document = this.getDocument(uri);
14979 if (document) {
14980 return document;
14981 }
14982 document = await this.langiumDocumentFactory.fromUri(uri, cancellationToken);
14983 this.addDocument(document);
14984 return document;
14985 }
14986 createDocument(uri, text, cancellationToken) {
14987 if (cancellationToken) {
14988 return this.langiumDocumentFactory.fromString(text, uri, cancellationToken).then(document => {
14989 this.addDocument(document);
14990 return document;
14991 });
14992 }
14993 else {
14994 const document = this.langiumDocumentFactory.fromString(text, uri);
14995 this.addDocument(document);
14996 return document;
14997 }
14998 }
14999 hasDocument(uri) {
15000 return this.documentMap.has(uri.toString());
15001 }
15002 invalidateDocument(uri) {
15003 const uriString = uri.toString();
15004 const langiumDoc = this.documentMap.get(uriString);
15005 if (langiumDoc) {
15006 const linker = this.serviceRegistry.getServices(uri).references.Linker;
15007 linker.unlink(langiumDoc);
15008 langiumDoc.state = DocumentState.Changed;
15009 langiumDoc.precomputedScopes = undefined;
15010 langiumDoc.diagnostics = undefined;
15011 }
15012 return langiumDoc;
15013 }
15014 deleteDocument(uri) {
15015 const uriString = uri.toString();
15016 const langiumDoc = this.documentMap.get(uriString);
15017 if (langiumDoc) {
15018 langiumDoc.state = DocumentState.Changed;
15019 this.documentMap.delete(uriString);
15020 }
15021 return langiumDoc;
15022 }
15023 }
15024 //# sourceMappingURL=documents.js.map
15025 ;// CONCATENATED MODULE: ../node_modules/langium/lib/references/linker.js
15026 /******************************************************************************
15027 * Copyright 2021 TypeFox GmbH
15028 * This program and the accompanying materials are made available under the
15029 * terms of the MIT License, which is available in the project root.
15030 ******************************************************************************/
15031
15032
15033
15034
15035
15036 const ref_resolving = Symbol('ref_resolving');
15037 class DefaultLinker {
15038 constructor(services) {
15039 this.reflection = services.shared.AstReflection;
15040 this.langiumDocuments = () => services.shared.workspace.LangiumDocuments;
15041 this.scopeProvider = services.references.ScopeProvider;
15042 this.astNodeLocator = services.workspace.AstNodeLocator;
15043 }
15044 async link(document, cancelToken = cancellation.CancellationToken.None) {
15045 for (const node of (0,ast_utils/* streamAst */.Zc)(document.parseResult.value)) {
15046 await interruptAndCheck(cancelToken);
15047 (0,ast_utils/* streamReferences */.fy)(node).forEach(ref => this.doLink(ref, document));
15048 }
15049 }
15050 doLink(refInfo, document) {
15051 var _a;
15052 const ref = refInfo.reference;
15053 // The reference may already have been resolved lazily by accessing its `ref` property.
15054 if (ref._ref === undefined) {
15055 ref._ref = ref_resolving;
15056 try {
15057 const description = this.getCandidate(refInfo);
15058 if ((0,syntax_tree/* isLinkingError */.et)(description)) {
15059 ref._ref = description;
15060 }
15061 else {
15062 ref._nodeDescription = description;
15063 if (this.langiumDocuments().hasDocument(description.documentUri)) {
15064 // The target document is already loaded
15065 const linkedNode = this.loadAstNode(description);
15066 ref._ref = linkedNode !== null && linkedNode !== void 0 ? linkedNode : this.createLinkingError(refInfo, description);
15067 }
15068 else {
15069 // Try to load the target AST node later using the already provided description
15070 ref._ref = undefined;
15071 }
15072 }
15073 }
15074 catch (err) {
15075 console.error(`An error occurred while resolving reference to '${ref.$refText}':`, err);
15076 const errorMessage = (_a = err.message) !== null && _a !== void 0 ? _a : String(err);
15077 ref._ref = Object.assign(Object.assign({}, refInfo), { message: `An error occurred while resolving reference to '${ref.$refText}': ${errorMessage}` });
15078 }
15079 // Add the reference to the document's array of references
15080 // Only add if the reference has been not been resolved earlier
15081 // Otherwise we end up with duplicates
15082 // See also implementation of `buildReference`
15083 document.references.push(ref);
15084 }
15085 }
15086 unlink(document) {
15087 for (const ref of document.references) {
15088 delete ref._ref;
15089 delete ref._nodeDescription;
15090 }
15091 document.references = [];
15092 }
15093 getCandidate(refInfo) {
15094 const scope = this.scopeProvider.getScope(refInfo);
15095 const description = scope.getElement(refInfo.reference.$refText);
15096 return description !== null && description !== void 0 ? description : this.createLinkingError(refInfo);
15097 }
15098 buildReference(node, property, refNode, refText) {
15099 // See behavior description in doc of Linker, update that on changes in here.
15100 // eslint-disable-next-line @typescript-eslint/no-this-alias
15101 const linker = this;
15102 const reference = {
15103 $refNode: refNode,
15104 $refText: refText,
15105 get ref() {
15106 var _a;
15107 if ((0,syntax_tree/* isAstNode */.xA)(this._ref)) {
15108 // Most frequent case: the target is already resolved.
15109 return this._ref;
15110 }
15111 else if ((0,syntax_tree/* isAstNodeDescription */.SI)(this._nodeDescription)) {
15112 // A candidate has been found before, but it is not loaded yet.
15113 const linkedNode = linker.loadAstNode(this._nodeDescription);
15114 this._ref = linkedNode !== null && linkedNode !== void 0 ? linkedNode : linker.createLinkingError({ reference, container: node, property }, this._nodeDescription);
15115 }
15116 else if (this._ref === undefined) {
15117 // The reference has not been linked yet, so do that now.
15118 this._ref = ref_resolving;
15119 const document = (0,ast_utils/* findRootNode */.E$)(node).$document;
15120 const refData = linker.getLinkedNode({ reference, container: node, property });
15121 if (refData.error && document && document.state < DocumentState.ComputedScopes) {
15122 // Document scope is not ready, don't set `this._ref` so linker can retry later.
15123 return this._ref = undefined;
15124 }
15125 this._ref = (_a = refData.node) !== null && _a !== void 0 ? _a : refData.error;
15126 this._nodeDescription = refData.descr;
15127 document === null || document === void 0 ? void 0 : document.references.push(this);
15128 }
15129 else if (this._ref === ref_resolving) {
15130 throw new Error(`Cyclic reference resolution detected: ${linker.astNodeLocator.getAstNodePath(node)}/${property} (symbol '${refText}')`);
15131 }
15132 return (0,syntax_tree/* isAstNode */.xA)(this._ref) ? this._ref : undefined;
15133 },
15134 get $nodeDescription() {
15135 return this._nodeDescription;
15136 },
15137 get error() {
15138 return (0,syntax_tree/* isLinkingError */.et)(this._ref) ? this._ref : undefined;
15139 }
15140 };
15141 return reference;
15142 }
15143 getLinkedNode(refInfo) {
15144 var _a;
15145 try {
15146 const description = this.getCandidate(refInfo);
15147 if ((0,syntax_tree/* isLinkingError */.et)(description)) {
15148 return { error: description };
15149 }
15150 const linkedNode = this.loadAstNode(description);
15151 if (linkedNode) {
15152 return { node: linkedNode, descr: description };
15153 }
15154 else {
15155 return {
15156 descr: description,
15157 error: this.createLinkingError(refInfo, description)
15158 };
15159 }
15160 }
15161 catch (err) {
15162 console.error(`An error occurred while resolving reference to '${refInfo.reference.$refText}':`, err);
15163 const errorMessage = (_a = err.message) !== null && _a !== void 0 ? _a : String(err);
15164 return {
15165 error: Object.assign(Object.assign({}, refInfo), { message: `An error occurred while resolving reference to '${refInfo.reference.$refText}': ${errorMessage}` })
15166 };
15167 }
15168 }
15169 loadAstNode(nodeDescription) {
15170 if (nodeDescription.node) {
15171 return nodeDescription.node;
15172 }
15173 const doc = this.langiumDocuments().getDocument(nodeDescription.documentUri);
15174 if (!doc) {
15175 return undefined;
15176 }
15177 return this.astNodeLocator.getAstNode(doc.parseResult.value, nodeDescription.path);
15178 }
15179 createLinkingError(refInfo, targetDescription) {
15180 // Check whether the document is sufficiently processed by the DocumentBuilder. If not, this is a hint for a bug
15181 // in the language implementation.
15182 const document = (0,ast_utils/* findRootNode */.E$)(refInfo.container).$document;
15183 if (document && document.state < DocumentState.ComputedScopes) {
15184 console.warn(`Attempted reference resolution before document reached ComputedScopes state (${document.uri}).`);
15185 }
15186 const referenceType = this.reflection.getReferenceType(refInfo);
15187 return Object.assign(Object.assign({}, refInfo), { message: `Could not resolve reference to ${referenceType} named '${refInfo.reference.$refText}'.`, targetDescription });
15188 }
15189 }
15190 //# sourceMappingURL=linker.js.map
15191 ;// CONCATENATED MODULE: ../node_modules/langium/lib/references/name-provider.js
15192 /******************************************************************************
15193 * Copyright 2021 TypeFox GmbH
15194 * This program and the accompanying materials are made available under the
15195 * terms of the MIT License, which is available in the project root.
15196 ******************************************************************************/
15197
15198 function isNamed(node) {
15199 return typeof node.name === 'string';
15200 }
15201 class DefaultNameProvider {
15202 getName(node) {
15203 if (isNamed(node)) {
15204 return node.name;
15205 }
15206 return undefined;
15207 }
15208 getNameNode(node) {
15209 return (0,grammar_utils/* findNodeForProperty */.vb)(node.$cstNode, 'name');
15210 }
15211 }
15212 //# sourceMappingURL=name-provider.js.map
15213 ;// CONCATENATED MODULE: ../node_modules/langium/lib/utils/uri-utils.js
15214 /******************************************************************************
15215 * Copyright 2022 TypeFox GmbH
15216 * This program and the accompanying materials are made available under the
15217 * terms of the MIT License, which is available in the project root.
15218 ******************************************************************************/
15219
15220
15221 var UriUtils;
15222 (function (UriUtils) {
15223 UriUtils.basename = esm/* Utils */.c.basename;
15224 UriUtils.dirname = esm/* Utils */.c.dirname;
15225 UriUtils.extname = esm/* Utils */.c.extname;
15226 UriUtils.joinPath = esm/* Utils */.c.joinPath;
15227 UriUtils.resolvePath = esm/* Utils */.c.resolvePath;
15228 function equals(a, b) {
15229 return (a === null || a === void 0 ? void 0 : a.toString()) === (b === null || b === void 0 ? void 0 : b.toString());
15230 }
15231 UriUtils.equals = equals;
15232 function relative(from, to) {
15233 const fromPath = typeof from === 'string' ? from : from.path;
15234 const toPath = typeof to === 'string' ? to : to.path;
15235 const fromParts = fromPath.split('/').filter(e => e.length > 0);
15236 const toParts = toPath.split('/').filter(e => e.length > 0);
15237 let i = 0;
15238 for (; i < fromParts.length; i++) {
15239 if (fromParts[i] !== toParts[i]) {
15240 break;
15241 }
15242 }
15243 const backPart = '../'.repeat(fromParts.length - i);
15244 const toPart = toParts.slice(i).join('/');
15245 return backPart + toPart;
15246 }
15247 UriUtils.relative = relative;
15248 function normalize(uri) {
15249 return esm/* URI */.o.parse(uri.toString()).toString();
15250 }
15251 UriUtils.normalize = normalize;
15252 })(UriUtils || (UriUtils = {}));
15253 //# sourceMappingURL=uri-utils.js.map
15254 ;// CONCATENATED MODULE: ../node_modules/langium/lib/references/references.js
15255 /******************************************************************************
15256 * Copyright 2021 TypeFox GmbH
15257 * This program and the accompanying materials are made available under the
15258 * terms of the MIT License, which is available in the project root.
15259 ******************************************************************************/
15260
15261
15262
15263
15264
15265
15266 class DefaultReferences {
15267 constructor(services) {
15268 this.nameProvider = services.references.NameProvider;
15269 this.index = services.shared.workspace.IndexManager;
15270 this.nodeLocator = services.workspace.AstNodeLocator;
15271 }
15272 findDeclaration(sourceCstNode) {
15273 if (sourceCstNode) {
15274 const assignment = (0,grammar_utils/* findAssignment */.h7)(sourceCstNode);
15275 const nodeElem = sourceCstNode.astNode;
15276 if (assignment && nodeElem) {
15277 const reference = nodeElem[assignment.feature];
15278 if ((0,syntax_tree/* isReference */.Yk)(reference)) {
15279 return reference.ref;
15280 }
15281 else if (Array.isArray(reference)) {
15282 for (const ref of reference) {
15283 if ((0,syntax_tree/* isReference */.Yk)(ref) && ref.$refNode
15284 && ref.$refNode.offset <= sourceCstNode.offset
15285 && ref.$refNode.end >= sourceCstNode.end) {
15286 return ref.ref;
15287 }
15288 }
15289 }
15290 }
15291 if (nodeElem) {
15292 const nameNode = this.nameProvider.getNameNode(nodeElem);
15293 // Only return the targeted node in case the targeted cst node is the name node or part of it
15294 if (nameNode && (nameNode === sourceCstNode || (0,cst_utils/* isChildNode */.OB)(sourceCstNode, nameNode))) {
15295 return nodeElem;
15296 }
15297 }
15298 }
15299 return undefined;
15300 }
15301 findDeclarationNode(sourceCstNode) {
15302 const astNode = this.findDeclaration(sourceCstNode);
15303 if (astNode === null || astNode === void 0 ? void 0 : astNode.$cstNode) {
15304 const targetNode = this.nameProvider.getNameNode(astNode);
15305 return targetNode !== null && targetNode !== void 0 ? targetNode : astNode.$cstNode;
15306 }
15307 return undefined;
15308 }
15309 findReferences(targetNode, options) {
15310 const refs = [];
15311 if (options.includeDeclaration) {
15312 const ref = this.getReferenceToSelf(targetNode);
15313 if (ref) {
15314 refs.push(ref);
15315 }
15316 }
15317 let indexReferences = this.index.findAllReferences(targetNode, this.nodeLocator.getAstNodePath(targetNode));
15318 if (options.documentUri) {
15319 indexReferences = indexReferences.filter(ref => UriUtils.equals(ref.sourceUri, options.documentUri));
15320 }
15321 refs.push(...indexReferences);
15322 return (0,stream/* stream */.Vw)(refs);
15323 }
15324 getReferenceToSelf(targetNode) {
15325 const nameNode = this.nameProvider.getNameNode(targetNode);
15326 if (nameNode) {
15327 const doc = (0,ast_utils/* getDocument */.Me)(targetNode);
15328 const path = this.nodeLocator.getAstNodePath(targetNode);
15329 return {
15330 sourceUri: doc.uri,
15331 sourcePath: path,
15332 targetUri: doc.uri,
15333 targetPath: path,
15334 segment: (0,cst_utils/* toDocumentSegment */.yn)(nameNode),
15335 local: true
15336 };
15337 }
15338 return undefined;
15339 }
15340 }
15341 //# sourceMappingURL=references.js.map
15342 ;// CONCATENATED MODULE: ../node_modules/langium/lib/utils/collections.js
15343 /******************************************************************************
15344 * Copyright 2021 TypeFox GmbH
15345 * This program and the accompanying materials are made available under the
15346 * terms of the MIT License, which is available in the project root.
15347 ******************************************************************************/
15348
15349 /**
15350 * A multimap is a variation of a Map that has potentially multiple values for every key.
15351 */
15352 class MultiMap {
15353 constructor(elements) {
15354 this.map = new Map();
15355 if (elements) {
15356 for (const [key, value] of elements) {
15357 this.add(key, value);
15358 }
15359 }
15360 }
15361 /**
15362 * The total number of values in the multimap.
15363 */
15364 get size() {
15365 return stream/* Reduction */.IH.sum((0,stream/* stream */.Vw)(this.map.values()).map(a => a.length));
15366 }
15367 /**
15368 * Clear all entries in the multimap.
15369 */
15370 clear() {
15371 this.map.clear();
15372 }
15373 /**
15374 * Operates differently depending on whether a `value` is given:
15375 * * With a value, this method deletes the specific key / value pair from the multimap.
15376 * * Without a value, all values associated with the given key are deleted.
15377 *
15378 * @returns `true` if a value existed and has been removed, or `false` if the specified
15379 * key / value does not exist.
15380 */
15381 delete(key, value) {
15382 if (value === undefined) {
15383 return this.map.delete(key);
15384 }
15385 else {
15386 const values = this.map.get(key);
15387 if (values) {
15388 const index = values.indexOf(value);
15389 if (index >= 0) {
15390 if (values.length === 1) {
15391 this.map.delete(key);
15392 }
15393 else {
15394 values.splice(index, 1);
15395 }
15396 return true;
15397 }
15398 }
15399 return false;
15400 }
15401 }
15402 /**
15403 * Returns an array of all values associated with the given key. If no value exists,
15404 * an empty array is returned.
15405 *
15406 * _Note:_ The returned array is assumed not to be modified. Use the `set` method to add a
15407 * value and `delete` to remove a value from the multimap.
15408 */
15409 get(key) {
15410 var _a;
15411 return (_a = this.map.get(key)) !== null && _a !== void 0 ? _a : [];
15412 }
15413 /**
15414 * Operates differently depending on whether a `value` is given:
15415 * * With a value, this method returns `true` if the specific key / value pair is present in the multimap.
15416 * * Without a value, this method returns `true` if the given key is present in the multimap.
15417 */
15418 has(key, value) {
15419 if (value === undefined) {
15420 return this.map.has(key);
15421 }
15422 else {
15423 const values = this.map.get(key);
15424 if (values) {
15425 return values.indexOf(value) >= 0;
15426 }
15427 return false;
15428 }
15429 }
15430 /**
15431 * Add the given key / value pair to the multimap.
15432 */
15433 add(key, value) {
15434 if (this.map.has(key)) {
15435 this.map.get(key).push(value);
15436 }
15437 else {
15438 this.map.set(key, [value]);
15439 }
15440 return this;
15441 }
15442 /**
15443 * Add the given set of key / value pairs to the multimap.
15444 */
15445 addAll(key, values) {
15446 if (this.map.has(key)) {
15447 this.map.get(key).push(...values);
15448 }
15449 else {
15450 this.map.set(key, Array.from(values));
15451 }
15452 return this;
15453 }
15454 /**
15455 * Invokes the given callback function for every key / value pair in the multimap.
15456 */
15457 forEach(callbackfn) {
15458 this.map.forEach((array, key) => array.forEach(value => callbackfn(value, key, this)));
15459 }
15460 /**
15461 * Returns an iterator of key, value pairs for every entry in the map.
15462 */
15463 [Symbol.iterator]() {
15464 return this.entries().iterator();
15465 }
15466 /**
15467 * Returns a stream of key, value pairs for every entry in the map.
15468 */
15469 entries() {
15470 return (0,stream/* stream */.Vw)(this.map.entries())
15471 .flatMap(([key, array]) => array.map(value => [key, value]));
15472 }
15473 /**
15474 * Returns a stream of keys in the map.
15475 */
15476 keys() {
15477 return (0,stream/* stream */.Vw)(this.map.keys());
15478 }
15479 /**
15480 * Returns a stream of values in the map.
15481 */
15482 values() {
15483 return (0,stream/* stream */.Vw)(this.map.values()).flat();
15484 }
15485 /**
15486 * Returns a stream of key, value set pairs for every key in the map.
15487 */
15488 entriesGroupedByKey() {
15489 return (0,stream/* stream */.Vw)(this.map.entries());
15490 }
15491 }
15492 class BiMap {
15493 get size() {
15494 return this.map.size;
15495 }
15496 constructor(elements) {
15497 this.map = new Map();
15498 this.inverse = new Map();
15499 if (elements) {
15500 for (const [key, value] of elements) {
15501 this.set(key, value);
15502 }
15503 }
15504 }
15505 clear() {
15506 this.map.clear();
15507 this.inverse.clear();
15508 }
15509 set(key, value) {
15510 this.map.set(key, value);
15511 this.inverse.set(value, key);
15512 return this;
15513 }
15514 get(key) {
15515 return this.map.get(key);
15516 }
15517 getKey(value) {
15518 return this.inverse.get(value);
15519 }
15520 delete(key) {
15521 const value = this.map.get(key);
15522 if (value !== undefined) {
15523 this.map.delete(key);
15524 this.inverse.delete(value);
15525 return true;
15526 }
15527 return false;
15528 }
15529 }
15530 //# sourceMappingURL=collections.js.map
15531 ;// CONCATENATED MODULE: ../node_modules/langium/lib/references/scope-computation.js
15532 /******************************************************************************
15533 * Copyright 2021-2022 TypeFox GmbH
15534 * This program and the accompanying materials are made available under the
15535 * terms of the MIT License, which is available in the project root.
15536 ******************************************************************************/
15537
15538
15539
15540
15541 /**
15542 * The default scope computation creates and collectes descriptions of the AST nodes to be exported into the
15543 * _global_ scope from the given document. By default those are the document's root AST node and its directly
15544 * contained child nodes.
15545 *
15546 * Besides, it gathers all AST nodes that have a name (according to the `NameProvider` service) and includes them
15547 * in the local scope of their particular container nodes. As a result, for every cross-reference in the AST,
15548 * target elements from the same level (siblings) and further up towards the root (parents and siblings of parents)
15549 * are visible. Elements being nested inside lower levels (children, children of siblings and parents' siblings)
15550 * are _invisible_ by default, but that can be changed by customizing this service.
15551 */
15552 class DefaultScopeComputation {
15553 constructor(services) {
15554 this.nameProvider = services.references.NameProvider;
15555 this.descriptions = services.workspace.AstNodeDescriptionProvider;
15556 }
15557 async computeExports(document, cancelToken = cancellation.CancellationToken.None) {
15558 return this.computeExportsForNode(document.parseResult.value, document, undefined, cancelToken);
15559 }
15560 /**
15561 * Creates {@link AstNodeDescription AstNodeDescriptions} for the given {@link AstNode parentNode} and its children.
15562 * The list of children to be considered is determined by the function parameter {@link children}.
15563 * By default only the direct children of {@link parentNode} are visited, nested nodes are not exported.
15564 *
15565 * @param parentNode AST node to be exported, i.e., of which an {@link AstNodeDescription} shall be added to the returned list.
15566 * @param document The document containing the AST node to be exported.
15567 * @param children A function called with {@link parentNode} as single argument and returning an {@link Iterable} supplying the children to be visited, which must be directly or transitively contained in {@link parentNode}.
15568 * @param cancelToken Indicates when to cancel the current operation.
15569 * @throws `OperationCancelled` if a user action occurs during execution.
15570 * @returns A list of {@link AstNodeDescription AstNodeDescriptions} to be published to index.
15571 */
15572 async computeExportsForNode(parentNode, document, children = ast_utils/* streamContents */.sx, cancelToken = cancellation.CancellationToken.None) {
15573 const exports = [];
15574 this.exportNode(parentNode, exports, document);
15575 for (const node of children(parentNode)) {
15576 await interruptAndCheck(cancelToken);
15577 this.exportNode(node, exports, document);
15578 }
15579 return exports;
15580 }
15581 /**
15582 * Add a single node to the list of exports if it has a name. Override this method to change how
15583 * symbols are exported, e.g. by modifying their exported name.
15584 */
15585 exportNode(node, exports, document) {
15586 const name = this.nameProvider.getName(node);
15587 if (name) {
15588 exports.push(this.descriptions.createDescription(node, name, document));
15589 }
15590 }
15591 async computeLocalScopes(document, cancelToken = cancellation.CancellationToken.None) {
15592 const rootNode = document.parseResult.value;
15593 const scopes = new MultiMap();
15594 // Here we navigate the full AST - local scopes shall be available in the whole document
15595 for (const node of (0,ast_utils/* streamAllContents */.VY)(rootNode)) {
15596 await interruptAndCheck(cancelToken);
15597 this.processNode(node, document, scopes);
15598 }
15599 return scopes;
15600 }
15601 /**
15602 * Process a single node during scopes computation. The default implementation makes the node visible
15603 * in the subtree of its container (if the node has a name). Override this method to change this,
15604 * e.g. by increasing the visibility to a higher level in the AST.
15605 */
15606 processNode(node, document, scopes) {
15607 const container = node.$container;
15608 if (container) {
15609 const name = this.nameProvider.getName(node);
15610 if (name) {
15611 scopes.add(container, this.descriptions.createDescription(node, name, document));
15612 }
15613 }
15614 }
15615 }
15616 //# sourceMappingURL=scope-computation.js.map
15617 ;// CONCATENATED MODULE: ../node_modules/langium/lib/references/scope.js
15618 /******************************************************************************
15619 * Copyright 2023 TypeFox GmbH
15620 * This program and the accompanying materials are made available under the
15621 * terms of the MIT License, which is available in the project root.
15622 ******************************************************************************/
15623
15624 /**
15625 * The default scope implementation is based on a `Stream`. It has an optional _outer scope_ describing
15626 * the next level of elements, which are queried when a target element is not found in the stream provided
15627 * to this scope.
15628 */
15629 class StreamScope {
15630 constructor(elements, outerScope, options) {
15631 var _a;
15632 this.elements = elements;
15633 this.outerScope = outerScope;
15634 this.caseInsensitive = (_a = options === null || options === void 0 ? void 0 : options.caseInsensitive) !== null && _a !== void 0 ? _a : false;
15635 }
15636 getAllElements() {
15637 if (this.outerScope) {
15638 return this.elements.concat(this.outerScope.getAllElements());
15639 }
15640 else {
15641 return this.elements;
15642 }
15643 }
15644 getElement(name) {
15645 const local = this.caseInsensitive
15646 ? this.elements.find(e => e.name.toLowerCase() === name.toLowerCase())
15647 : this.elements.find(e => e.name === name);
15648 if (local) {
15649 return local;
15650 }
15651 if (this.outerScope) {
15652 return this.outerScope.getElement(name);
15653 }
15654 return undefined;
15655 }
15656 }
15657 class MapScope {
15658 constructor(elements, outerScope, options) {
15659 var _a;
15660 this.elements = new Map();
15661 this.caseInsensitive = (_a = options === null || options === void 0 ? void 0 : options.caseInsensitive) !== null && _a !== void 0 ? _a : false;
15662 for (const element of elements) {
15663 const name = this.caseInsensitive
15664 ? element.name.toLowerCase()
15665 : element.name;
15666 this.elements.set(name, element);
15667 }
15668 this.outerScope = outerScope;
15669 }
15670 getElement(name) {
15671 const localName = this.caseInsensitive ? name.toLowerCase() : name;
15672 const local = this.elements.get(localName);
15673 if (local) {
15674 return local;
15675 }
15676 if (this.outerScope) {
15677 return this.outerScope.getElement(name);
15678 }
15679 return undefined;
15680 }
15681 getAllElements() {
15682 let elementStream = (0,stream/* stream */.Vw)(this.elements.values());
15683 if (this.outerScope) {
15684 elementStream = elementStream.concat(this.outerScope.getAllElements());
15685 }
15686 return elementStream;
15687 }
15688 }
15689 const EMPTY_SCOPE = {
15690 getElement() {
15691 return undefined;
15692 },
15693 getAllElements() {
15694 return stream/* EMPTY_STREAM */.Cl;
15695 }
15696 };
15697 //# sourceMappingURL=scope.js.map
15698 ;// CONCATENATED MODULE: ../node_modules/langium/lib/utils/caching.js
15699 /******************************************************************************
15700 * Copyright 2023 TypeFox GmbH
15701 * This program and the accompanying materials are made available under the
15702 * terms of the MIT License, which is available in the project root.
15703 ******************************************************************************/
15704 class DisposableCache {
15705 constructor() {
15706 this.toDispose = [];
15707 this.isDisposed = false;
15708 }
15709 onDispose(disposable) {
15710 this.toDispose.push(disposable);
15711 }
15712 dispose() {
15713 this.throwIfDisposed();
15714 this.clear();
15715 this.isDisposed = true;
15716 this.toDispose.forEach(disposable => disposable.dispose());
15717 }
15718 throwIfDisposed() {
15719 if (this.isDisposed) {
15720 throw new Error('This cache has already been disposed');
15721 }
15722 }
15723 }
15724 class SimpleCache extends DisposableCache {
15725 constructor() {
15726 super(...arguments);
15727 this.cache = new Map();
15728 }
15729 has(key) {
15730 this.throwIfDisposed();
15731 return this.cache.has(key);
15732 }
15733 set(key, value) {
15734 this.throwIfDisposed();
15735 this.cache.set(key, value);
15736 }
15737 get(key, provider) {
15738 this.throwIfDisposed();
15739 if (this.cache.has(key)) {
15740 return this.cache.get(key);
15741 }
15742 else if (provider) {
15743 const value = provider();
15744 this.cache.set(key, value);
15745 return value;
15746 }
15747 else {
15748 return undefined;
15749 }
15750 }
15751 delete(key) {
15752 this.throwIfDisposed();
15753 return this.cache.delete(key);
15754 }
15755 clear() {
15756 this.throwIfDisposed();
15757 this.cache.clear();
15758 }
15759 }
15760 class ContextCache extends DisposableCache {
15761 constructor(converter) {
15762 super();
15763 this.cache = new Map();
15764 this.converter = converter !== null && converter !== void 0 ? converter : (value => value);
15765 }
15766 has(contextKey, key) {
15767 this.throwIfDisposed();
15768 return this.cacheForContext(contextKey).has(key);
15769 }
15770 set(contextKey, key, value) {
15771 this.throwIfDisposed();
15772 this.cacheForContext(contextKey).set(key, value);
15773 }
15774 get(contextKey, key, provider) {
15775 this.throwIfDisposed();
15776 const contextCache = this.cacheForContext(contextKey);
15777 if (contextCache.has(key)) {
15778 return contextCache.get(key);
15779 }
15780 else if (provider) {
15781 const value = provider();
15782 contextCache.set(key, value);
15783 return value;
15784 }
15785 else {
15786 return undefined;
15787 }
15788 }
15789 delete(contextKey, key) {
15790 this.throwIfDisposed();
15791 return this.cacheForContext(contextKey).delete(key);
15792 }
15793 clear(contextKey) {
15794 this.throwIfDisposed();
15795 if (contextKey) {
15796 const mapKey = this.converter(contextKey);
15797 this.cache.delete(mapKey);
15798 }
15799 else {
15800 this.cache.clear();
15801 }
15802 }
15803 cacheForContext(contextKey) {
15804 const mapKey = this.converter(contextKey);
15805 let documentCache = this.cache.get(mapKey);
15806 if (!documentCache) {
15807 documentCache = new Map();
15808 this.cache.set(mapKey, documentCache);
15809 }
15810 return documentCache;
15811 }
15812 }
15813 /**
15814 * Every key/value pair in this cache is scoped to a document.
15815 * If this document is changed or deleted, all associated key/value pairs are deleted.
15816 */
15817 class DocumentCache extends (/* unused pure expression or super */ null && (ContextCache)) {
15818 /**
15819 * Creates a new document cache.
15820 *
15821 * @param sharedServices Service container instance to hook into document lifecycle events.
15822 * @param state Optional document state on which the cache should evict.
15823 * If not provided, the cache will evict on `DocumentBuilder#onUpdate`.
15824 * *Deleted* documents are considered in both cases.
15825 *
15826 * Providing a state here will use `DocumentBuilder#onDocumentPhase` instead,
15827 * which triggers on all documents that have been affected by this change, assuming that the
15828 * state is `DocumentState.Linked` or a later state.
15829 */
15830 constructor(sharedServices, state) {
15831 super(uri => uri.toString());
15832 if (state) {
15833 this.toDispose.push(sharedServices.workspace.DocumentBuilder.onDocumentPhase(state, document => {
15834 this.clear(document.uri.toString());
15835 }));
15836 this.toDispose.push(sharedServices.workspace.DocumentBuilder.onUpdate((_changed, deleted) => {
15837 for (const uri of deleted) { // react only on deleted documents
15838 this.clear(uri);
15839 }
15840 }));
15841 }
15842 else {
15843 this.toDispose.push(sharedServices.workspace.DocumentBuilder.onUpdate((changed, deleted) => {
15844 const allUris = changed.concat(deleted); // react on both changed and deleted documents
15845 for (const uri of allUris) {
15846 this.clear(uri);
15847 }
15848 }));
15849 }
15850 }
15851 }
15852 /**
15853 * Every key/value pair in this cache is scoped to the whole workspace.
15854 * If any document in the workspace is added, changed or deleted, the whole cache is evicted.
15855 */
15856 class WorkspaceCache extends SimpleCache {
15857 /**
15858 * Creates a new workspace cache.
15859 *
15860 * @param sharedServices Service container instance to hook into document lifecycle events.
15861 * @param state Optional document state on which the cache should evict.
15862 * If not provided, the cache will evict on `DocumentBuilder#onUpdate`.
15863 * *Deleted* documents are considered in both cases.
15864 */
15865 constructor(sharedServices, state) {
15866 super();
15867 if (state) {
15868 this.toDispose.push(sharedServices.workspace.DocumentBuilder.onBuildPhase(state, () => {
15869 this.clear();
15870 }));
15871 this.toDispose.push(sharedServices.workspace.DocumentBuilder.onUpdate((_changed, deleted) => {
15872 if (deleted.length > 0) { // react only on deleted documents
15873 this.clear();
15874 }
15875 }));
15876 }
15877 else {
15878 this.toDispose.push(sharedServices.workspace.DocumentBuilder.onUpdate(() => {
15879 this.clear();
15880 }));
15881 }
15882 }
15883 }
15884 //# sourceMappingURL=caching.js.map
15885 ;// CONCATENATED MODULE: ../node_modules/langium/lib/references/scope-provider.js
15886 /******************************************************************************
15887 * Copyright 2021-2022 TypeFox GmbH
15888 * This program and the accompanying materials are made available under the
15889 * terms of the MIT License, which is available in the project root.
15890 ******************************************************************************/
15891
15892
15893
15894
15895 class DefaultScopeProvider {
15896 constructor(services) {
15897 this.reflection = services.shared.AstReflection;
15898 this.nameProvider = services.references.NameProvider;
15899 this.descriptions = services.workspace.AstNodeDescriptionProvider;
15900 this.indexManager = services.shared.workspace.IndexManager;
15901 this.globalScopeCache = new WorkspaceCache(services.shared);
15902 }
15903 getScope(context) {
15904 const scopes = [];
15905 const referenceType = this.reflection.getReferenceType(context);
15906 const precomputed = (0,ast_utils/* getDocument */.Me)(context.container).precomputedScopes;
15907 if (precomputed) {
15908 let currentNode = context.container;
15909 do {
15910 const allDescriptions = precomputed.get(currentNode);
15911 if (allDescriptions.length > 0) {
15912 scopes.push((0,stream/* stream */.Vw)(allDescriptions).filter(desc => this.reflection.isSubtype(desc.type, referenceType)));
15913 }
15914 currentNode = currentNode.$container;
15915 } while (currentNode);
15916 }
15917 let result = this.getGlobalScope(referenceType, context);
15918 for (let i = scopes.length - 1; i >= 0; i--) {
15919 result = this.createScope(scopes[i], result);
15920 }
15921 return result;
15922 }
15923 /**
15924 * Create a scope for the given collection of AST node descriptions.
15925 */
15926 createScope(elements, outerScope, options) {
15927 return new StreamScope((0,stream/* stream */.Vw)(elements), outerScope, options);
15928 }
15929 /**
15930 * Create a scope for the given collection of AST nodes, which need to be transformed into respective
15931 * descriptions first. This is done using the `NameProvider` and `AstNodeDescriptionProvider` services.
15932 */
15933 createScopeForNodes(elements, outerScope, options) {
15934 const s = (0,stream/* stream */.Vw)(elements).map(e => {
15935 const name = this.nameProvider.getName(e);
15936 if (name) {
15937 return this.descriptions.createDescription(e, name);
15938 }
15939 return undefined;
15940 }).nonNullable();
15941 return new StreamScope(s, outerScope, options);
15942 }
15943 /**
15944 * Create a global scope filtered for the given reference type.
15945 */
15946 getGlobalScope(referenceType, _context) {
15947 return this.globalScopeCache.get(referenceType, () => new MapScope(this.indexManager.allElements(referenceType)));
15948 }
15949 }
15950 //# sourceMappingURL=scope-provider.js.map
15951 ;// CONCATENATED MODULE: ../node_modules/langium/lib/serializer/json-serializer.js
15952 /******************************************************************************
15953 * Copyright 2021 TypeFox GmbH
15954 * This program and the accompanying materials are made available under the
15955 * terms of the MIT License, which is available in the project root.
15956 ******************************************************************************/
15957
15958
15959
15960
15961 function isAstNodeWithComment(node) {
15962 return typeof node.$comment === 'string';
15963 }
15964 function isIntermediateReference(obj) {
15965 return typeof obj === 'object' && !!obj && ('$ref' in obj || '$error' in obj);
15966 }
15967 class DefaultJsonSerializer {
15968 constructor(services) {
15969 /** The set of AstNode properties to be ignored by the serializer. */
15970 this.ignoreProperties = new Set(['$container', '$containerProperty', '$containerIndex', '$document', '$cstNode']);
15971 this.langiumDocuments = services.shared.workspace.LangiumDocuments;
15972 this.astNodeLocator = services.workspace.AstNodeLocator;
15973 this.nameProvider = services.references.NameProvider;
15974 this.commentProvider = services.documentation.CommentProvider;
15975 }
15976 serialize(node, options) {
15977 const serializeOptions = options !== null && options !== void 0 ? options : {};
15978 const specificReplacer = options === null || options === void 0 ? void 0 : options.replacer;
15979 const defaultReplacer = (key, value) => this.replacer(key, value, serializeOptions);
15980 const replacer = specificReplacer ? (key, value) => specificReplacer(key, value, defaultReplacer) : defaultReplacer;
15981 try {
15982 this.currentDocument = (0,ast_utils/* getDocument */.Me)(node);
15983 return JSON.stringify(node, replacer, options === null || options === void 0 ? void 0 : options.space);
15984 }
15985 finally {
15986 this.currentDocument = undefined;
15987 }
15988 }
15989 deserialize(content, options) {
15990 const deserializeOptions = options !== null && options !== void 0 ? options : {};
15991 const root = JSON.parse(content);
15992 this.linkNode(root, root, deserializeOptions);
15993 return root;
15994 }
15995 replacer(key, value, { refText, sourceText, textRegions, comments, uriConverter }) {
15996 var _a, _b, _c, _d;
15997 if (this.ignoreProperties.has(key)) {
15998 return undefined;
15999 }
16000 else if ((0,syntax_tree/* isReference */.Yk)(value)) {
16001 const refValue = value.ref;
16002 const $refText = refText ? value.$refText : undefined;
16003 if (refValue) {
16004 const targetDocument = (0,ast_utils/* getDocument */.Me)(refValue);
16005 let targetUri = '';
16006 if (this.currentDocument && this.currentDocument !== targetDocument) {
16007 if (uriConverter) {
16008 targetUri = uriConverter(targetDocument.uri, value);
16009 }
16010 else {
16011 targetUri = targetDocument.uri.toString();
16012 }
16013 }
16014 const targetPath = this.astNodeLocator.getAstNodePath(refValue);
16015 return {
16016 $ref: `${targetUri}#${targetPath}`,
16017 $refText
16018 };
16019 }
16020 else {
16021 return {
16022 $error: (_b = (_a = value.error) === null || _a === void 0 ? void 0 : _a.message) !== null && _b !== void 0 ? _b : 'Could not resolve reference',
16023 $refText
16024 };
16025 }
16026 }
16027 else if ((0,syntax_tree/* isAstNode */.xA)(value)) {
16028 let astNode = undefined;
16029 if (textRegions) {
16030 astNode = this.addAstNodeRegionWithAssignmentsTo(Object.assign({}, value));
16031 if ((!key || value.$document) && (astNode === null || astNode === void 0 ? void 0 : astNode.$textRegion)) {
16032 // The document URI is added to the root node of the resulting JSON tree
16033 astNode.$textRegion.documentURI = (_c = this.currentDocument) === null || _c === void 0 ? void 0 : _c.uri.toString();
16034 }
16035 }
16036 if (sourceText && !key) {
16037 astNode !== null && astNode !== void 0 ? astNode : (astNode = Object.assign({}, value));
16038 astNode.$sourceText = (_d = value.$cstNode) === null || _d === void 0 ? void 0 : _d.text;
16039 }
16040 if (comments) {
16041 astNode !== null && astNode !== void 0 ? astNode : (astNode = Object.assign({}, value));
16042 const comment = this.commentProvider.getComment(value);
16043 if (comment) {
16044 astNode.$comment = comment.replace(/\r/g, '');
16045 }
16046 }
16047 return astNode !== null && astNode !== void 0 ? astNode : value;
16048 }
16049 else {
16050 return value;
16051 }
16052 }
16053 addAstNodeRegionWithAssignmentsTo(node) {
16054 const createDocumentSegment = cstNode => ({
16055 offset: cstNode.offset,
16056 end: cstNode.end,
16057 length: cstNode.length,
16058 range: cstNode.range,
16059 });
16060 if (node.$cstNode) {
16061 const textRegion = node.$textRegion = createDocumentSegment(node.$cstNode);
16062 const assignments = textRegion.assignments = {};
16063 Object.keys(node).filter(key => !key.startsWith('$')).forEach(key => {
16064 const propertyAssignments = (0,grammar_utils/* findNodesForProperty */.EL)(node.$cstNode, key).map(createDocumentSegment);
16065 if (propertyAssignments.length !== 0) {
16066 assignments[key] = propertyAssignments;
16067 }
16068 });
16069 return node;
16070 }
16071 return undefined;
16072 }
16073 linkNode(node, root, options, container, containerProperty, containerIndex) {
16074 for (const [propertyName, item] of Object.entries(node)) {
16075 if (Array.isArray(item)) {
16076 for (let index = 0; index < item.length; index++) {
16077 const element = item[index];
16078 if (isIntermediateReference(element)) {
16079 item[index] = this.reviveReference(node, propertyName, root, element, options);
16080 }
16081 else if ((0,syntax_tree/* isAstNode */.xA)(element)) {
16082 this.linkNode(element, root, options, node, propertyName, index);
16083 }
16084 }
16085 }
16086 else if (isIntermediateReference(item)) {
16087 node[propertyName] = this.reviveReference(node, propertyName, root, item, options);
16088 }
16089 else if ((0,syntax_tree/* isAstNode */.xA)(item)) {
16090 this.linkNode(item, root, options, node, propertyName);
16091 }
16092 }
16093 const mutable = node;
16094 mutable.$container = container;
16095 mutable.$containerProperty = containerProperty;
16096 mutable.$containerIndex = containerIndex;
16097 }
16098 reviveReference(container, property, root, reference, options) {
16099 let refText = reference.$refText;
16100 let error = reference.$error;
16101 if (reference.$ref) {
16102 const ref = this.getRefNode(root, reference.$ref, options.uriConverter);
16103 if ((0,syntax_tree/* isAstNode */.xA)(ref)) {
16104 if (!refText) {
16105 refText = this.nameProvider.getName(ref);
16106 }
16107 return {
16108 $refText: refText !== null && refText !== void 0 ? refText : '',
16109 ref
16110 };
16111 }
16112 else {
16113 error = ref;
16114 }
16115 }
16116 if (error) {
16117 const ref = {
16118 $refText: refText !== null && refText !== void 0 ? refText : ''
16119 };
16120 ref.error = {
16121 container,
16122 property,
16123 message: error,
16124 reference: ref
16125 };
16126 return ref;
16127 }
16128 else {
16129 return undefined;
16130 }
16131 }
16132 getRefNode(root, uri, uriConverter) {
16133 try {
16134 const fragmentIndex = uri.indexOf('#');
16135 if (fragmentIndex === 0) {
16136 const node = this.astNodeLocator.getAstNode(root, uri.substring(1));
16137 if (!node) {
16138 return 'Could not resolve path: ' + uri;
16139 }
16140 return node;
16141 }
16142 if (fragmentIndex < 0) {
16143 const documentUri = uriConverter ? uriConverter(uri) : esm/* URI */.o.parse(uri);
16144 const document = this.langiumDocuments.getDocument(documentUri);
16145 if (!document) {
16146 return 'Could not find document for URI: ' + uri;
16147 }
16148 return document.parseResult.value;
16149 }
16150 const documentUri = uriConverter ? uriConverter(uri.substring(0, fragmentIndex)) : esm/* URI */.o.parse(uri.substring(0, fragmentIndex));
16151 const document = this.langiumDocuments.getDocument(documentUri);
16152 if (!document) {
16153 return 'Could not find document for URI: ' + uri;
16154 }
16155 if (fragmentIndex === uri.length - 1) {
16156 return document.parseResult.value;
16157 }
16158 const node = this.astNodeLocator.getAstNode(document.parseResult.value, uri.substring(fragmentIndex + 1));
16159 if (!node) {
16160 return 'Could not resolve URI: ' + uri;
16161 }
16162 return node;
16163 }
16164 catch (err) {
16165 return String(err);
16166 }
16167 }
16168 }
16169 //# sourceMappingURL=json-serializer.js.map
16170 ;// CONCATENATED MODULE: ../node_modules/langium/lib/service-registry.js
16171 /******************************************************************************
16172 * Copyright 2021 TypeFox GmbH
16173 * This program and the accompanying materials are made available under the
16174 * terms of the MIT License, which is available in the project root.
16175 ******************************************************************************/
16176
16177 /**
16178 * Generic registry for Langium services, but capable of being used with extending service sets as well (such as the lsp-complete LangiumCoreServices set)
16179 */
16180 class DefaultServiceRegistry {
16181 /**
16182 * @deprecated Use the new `fileExtensionMap` (or `languageIdMap`) property instead.
16183 */
16184 get map() {
16185 return this.fileExtensionMap;
16186 }
16187 constructor(services) {
16188 this.languageIdMap = new Map();
16189 this.fileExtensionMap = new Map();
16190 this.textDocuments = services === null || services === void 0 ? void 0 : services.workspace.TextDocuments;
16191 }
16192 register(language) {
16193 const data = language.LanguageMetaData;
16194 for (const ext of data.fileExtensions) {
16195 if (this.fileExtensionMap.has(ext)) {
16196 console.warn(`The file extension ${ext} is used by multiple languages. It is now assigned to '${data.languageId}'.`);
16197 }
16198 this.fileExtensionMap.set(ext, language);
16199 }
16200 this.languageIdMap.set(data.languageId, language);
16201 if (this.languageIdMap.size === 1) {
16202 this.singleton = language;
16203 }
16204 else {
16205 this.singleton = undefined;
16206 }
16207 }
16208 getServices(uri) {
16209 var _a, _b;
16210 if (this.singleton !== undefined) {
16211 return this.singleton;
16212 }
16213 if (this.languageIdMap.size === 0) {
16214 throw new Error('The service registry is empty. Use `register` to register the services of a language.');
16215 }
16216 const languageId = (_b = (_a = this.textDocuments) === null || _a === void 0 ? void 0 : _a.get(uri)) === null || _b === void 0 ? void 0 : _b.languageId;
16217 if (languageId !== undefined) {
16218 const services = this.languageIdMap.get(languageId);
16219 if (services) {
16220 return services;
16221 }
16222 }
16223 const ext = UriUtils.extname(uri);
16224 const services = this.fileExtensionMap.get(ext);
16225 if (!services) {
16226 if (languageId) {
16227 throw new Error(`The service registry contains no services for the extension '${ext}' for language '${languageId}'.`);
16228 }
16229 else {
16230 throw new Error(`The service registry contains no services for the extension '${ext}'.`);
16231 }
16232 }
16233 return services;
16234 }
16235 hasServices(uri) {
16236 try {
16237 this.getServices(uri);
16238 return true;
16239 }
16240 catch (_a) {
16241 return false;
16242 }
16243 }
16244 get all() {
16245 return Array.from(this.languageIdMap.values());
16246 }
16247 }
16248 //# sourceMappingURL=service-registry.js.map
16249 ;// CONCATENATED MODULE: ../node_modules/langium/lib/validation/validation-registry.js
16250 /******************************************************************************
16251 * Copyright 2021 TypeFox GmbH
16252 * This program and the accompanying materials are made available under the
16253 * terms of the MIT License, which is available in the project root.
16254 ******************************************************************************/
16255
16256
16257
16258
16259 /**
16260 * Create DiagnosticData for a given diagnostic code. The result can be put into the `data` field of a DiagnosticInfo.
16261 */
16262 function diagnosticData(code) {
16263 return { code };
16264 }
16265 var ValidationCategory;
16266 (function (ValidationCategory) {
16267 ValidationCategory.all = ['fast', 'slow', 'built-in'];
16268 })(ValidationCategory || (ValidationCategory = {}));
16269 /**
16270 * Manages a set of `ValidationCheck`s to be applied when documents are validated.
16271 */
16272 class ValidationRegistry {
16273 constructor(services) {
16274 this.entries = new MultiMap();
16275 this.entriesBefore = [];
16276 this.entriesAfter = [];
16277 this.reflection = services.shared.AstReflection;
16278 }
16279 /**
16280 * Register a set of validation checks. Each value in the record can be either a single validation check (i.e. a function)
16281 * or an array of validation checks.
16282 *
16283 * @param checksRecord Set of validation checks to register.
16284 * @param category Optional category for the validation checks (defaults to `'fast'`).
16285 * @param thisObj Optional object to be used as `this` when calling the validation check functions.
16286 */
16287 register(checksRecord, thisObj = this, category = 'fast') {
16288 if (category === 'built-in') {
16289 throw new Error("The 'built-in' category is reserved for lexer, parser, and linker errors.");
16290 }
16291 for (const [type, ch] of Object.entries(checksRecord)) {
16292 const callbacks = ch;
16293 if (Array.isArray(callbacks)) {
16294 for (const check of callbacks) {
16295 const entry = {
16296 check: this.wrapValidationException(check, thisObj),
16297 category
16298 };
16299 this.addEntry(type, entry);
16300 }
16301 }
16302 else if (typeof callbacks === 'function') {
16303 const entry = {
16304 check: this.wrapValidationException(callbacks, thisObj),
16305 category
16306 };
16307 this.addEntry(type, entry);
16308 }
16309 else {
16310 (0,errors/* assertUnreachable */.U)(callbacks);
16311 }
16312 }
16313 }
16314 wrapValidationException(check, thisObj) {
16315 return async (node, accept, cancelToken) => {
16316 await this.handleException(() => check.call(thisObj, node, accept, cancelToken), 'An error occurred during validation', accept, node);
16317 };
16318 }
16319 async handleException(functionality, messageContext, accept, node) {
16320 try {
16321 await functionality();
16322 }
16323 catch (err) {
16324 if (isOperationCancelled(err)) {
16325 throw err;
16326 }
16327 console.error(`${messageContext}:`, err);
16328 if (err instanceof Error && err.stack) {
16329 console.error(err.stack);
16330 }
16331 const messageDetails = err instanceof Error ? err.message : String(err);
16332 accept('error', `${messageContext}: ${messageDetails}`, { node });
16333 }
16334 }
16335 addEntry(type, entry) {
16336 if (type === 'AstNode') {
16337 this.entries.add('AstNode', entry);
16338 return;
16339 }
16340 for (const subtype of this.reflection.getAllSubTypes(type)) {
16341 this.entries.add(subtype, entry);
16342 }
16343 }
16344 getChecks(type, categories) {
16345 let checks = (0,stream/* stream */.Vw)(this.entries.get(type))
16346 .concat(this.entries.get('AstNode'));
16347 if (categories) {
16348 checks = checks.filter(entry => categories.includes(entry.category));
16349 }
16350 return checks.map(entry => entry.check);
16351 }
16352 /**
16353 * Register logic which will be executed once before validating all the nodes of an AST/Langium document.
16354 * This helps to prepare or initialize some information which are required or reusable for the following checks on the AstNodes.
16355 *
16356 * As an example, for validating unique fully-qualified names of nodes in the AST,
16357 * here the map for mapping names to nodes could be established.
16358 * During the usual checks on the nodes, they are put into this map with their name.
16359 *
16360 * Note that this approach makes validations stateful, which is relevant e.g. when cancelling the validation.
16361 * Therefore it is recommended to clear stored information
16362 * _before_ validating an AST to validate each AST unaffected from other ASTs
16363 * AND _after_ validating the AST to free memory by information which are no longer used.
16364 *
16365 * @param checkBefore a set-up function which will be called once before actually validating an AST
16366 * @param thisObj Optional object to be used as `this` when calling the validation check functions.
16367 */
16368 registerBeforeDocument(checkBefore, thisObj = this) {
16369 this.entriesBefore.push(this.wrapPreparationException(checkBefore, 'An error occurred during set-up of the validation', thisObj));
16370 }
16371 /**
16372 * Register logic which will be executed once after validating all the nodes of an AST/Langium document.
16373 * This helps to finally evaluate information which are collected during the checks on the AstNodes.
16374 *
16375 * As an example, for validating unique fully-qualified names of nodes in the AST,
16376 * here the map with all the collected nodes and their names is checked
16377 * and validation hints are created for all nodes with the same name.
16378 *
16379 * Note that this approach makes validations stateful, which is relevant e.g. when cancelling the validation.
16380 * Therefore it is recommended to clear stored information
16381 * _before_ validating an AST to validate each AST unaffected from other ASTs
16382 * AND _after_ validating the AST to free memory by information which are no longer used.
16383 *
16384 * @param checkBefore a set-up function which will be called once before actually validating an AST
16385 * @param thisObj Optional object to be used as `this` when calling the validation check functions.
16386 */
16387 registerAfterDocument(checkAfter, thisObj = this) {
16388 this.entriesAfter.push(this.wrapPreparationException(checkAfter, 'An error occurred during tear-down of the validation', thisObj));
16389 }
16390 wrapPreparationException(check, messageContext, thisObj) {
16391 return async (rootNode, accept, categories, cancelToken) => {
16392 await this.handleException(() => check.call(thisObj, rootNode, accept, categories, cancelToken), messageContext, accept, rootNode);
16393 };
16394 }
16395 get checksBefore() {
16396 return this.entriesBefore;
16397 }
16398 get checksAfter() {
16399 return this.entriesAfter;
16400 }
16401 }
16402 //# sourceMappingURL=validation-registry.js.map
16403 ;// CONCATENATED MODULE: ../node_modules/langium/lib/validation/document-validator.js
16404 /******************************************************************************
16405 * Copyright 2021 TypeFox GmbH
16406 * This program and the accompanying materials are made available under the
16407 * terms of the MIT License, which is available in the project root.
16408 ******************************************************************************/
16409
16410
16411
16412
16413
16414
16415 class DefaultDocumentValidator {
16416 constructor(services) {
16417 this.validationRegistry = services.validation.ValidationRegistry;
16418 this.metadata = services.LanguageMetaData;
16419 }
16420 async validateDocument(document, options = {}, cancelToken = cancellation.CancellationToken.None) {
16421 const parseResult = document.parseResult;
16422 const diagnostics = [];
16423 await interruptAndCheck(cancelToken);
16424 if (!options.categories || options.categories.includes('built-in')) {
16425 this.processLexingErrors(parseResult, diagnostics, options);
16426 if (options.stopAfterLexingErrors && diagnostics.some(d => { var _a; return ((_a = d.data) === null || _a === void 0 ? void 0 : _a.code) === DocumentValidator.LexingError; })) {
16427 return diagnostics;
16428 }
16429 this.processParsingErrors(parseResult, diagnostics, options);
16430 if (options.stopAfterParsingErrors && diagnostics.some(d => { var _a; return ((_a = d.data) === null || _a === void 0 ? void 0 : _a.code) === DocumentValidator.ParsingError; })) {
16431 return diagnostics;
16432 }
16433 this.processLinkingErrors(document, diagnostics, options);
16434 if (options.stopAfterLinkingErrors && diagnostics.some(d => { var _a; return ((_a = d.data) === null || _a === void 0 ? void 0 : _a.code) === DocumentValidator.LinkingError; })) {
16435 return diagnostics;
16436 }
16437 }
16438 // Process custom validations
16439 try {
16440 diagnostics.push(...await this.validateAst(parseResult.value, options, cancelToken));
16441 }
16442 catch (err) {
16443 if (isOperationCancelled(err)) {
16444 throw err;
16445 }
16446 console.error('An error occurred during validation:', err);
16447 }
16448 await interruptAndCheck(cancelToken);
16449 return diagnostics;
16450 }
16451 processLexingErrors(parseResult, diagnostics, _options) {
16452 var _a, _b, _c;
16453 const lexerDiagnostics = [...parseResult.lexerErrors, ...(_b = (_a = parseResult.lexerReport) === null || _a === void 0 ? void 0 : _a.diagnostics) !== null && _b !== void 0 ? _b : []];
16454 for (const lexerDiagnostic of lexerDiagnostics) {
16455 const severity = (_c = lexerDiagnostic.severity) !== null && _c !== void 0 ? _c : 'error';
16456 const diagnostic = {
16457 severity: toDiagnosticSeverity(severity),
16458 range: {
16459 start: {
16460 line: lexerDiagnostic.line - 1,
16461 character: lexerDiagnostic.column - 1
16462 },
16463 end: {
16464 line: lexerDiagnostic.line - 1,
16465 character: lexerDiagnostic.column + lexerDiagnostic.length - 1
16466 }
16467 },
16468 message: lexerDiagnostic.message,
16469 data: toDiagnosticData(severity),
16470 source: this.getSource()
16471 };
16472 diagnostics.push(diagnostic);
16473 }
16474 }
16475 processParsingErrors(parseResult, diagnostics, _options) {
16476 for (const parserError of parseResult.parserErrors) {
16477 let range = undefined;
16478 // We can run into the chevrotain error recovery here
16479 // The token contained in the parser error might be automatically inserted
16480 // In this case every position value will be `NaN`
16481 if (isNaN(parserError.token.startOffset)) {
16482 // Some special parser error types contain a `previousToken`
16483 // We can simply append our diagnostic to that token
16484 if ('previousToken' in parserError) {
16485 const token = parserError.previousToken;
16486 if (!isNaN(token.startOffset)) {
16487 const position = { line: token.endLine - 1, character: token.endColumn };
16488 range = { start: position, end: position };
16489 }
16490 else {
16491 // No valid prev token. Might be empty document or containing only hidden tokens.
16492 // Point to document start
16493 const position = { line: 0, character: 0 };
16494 range = { start: position, end: position };
16495 }
16496 }
16497 }
16498 else {
16499 range = (0,cst_utils/* tokenToRange */.sp)(parserError.token);
16500 }
16501 if (range) {
16502 const diagnostic = {
16503 severity: toDiagnosticSeverity('error'),
16504 range,
16505 message: parserError.message,
16506 data: diagnosticData(DocumentValidator.ParsingError),
16507 source: this.getSource()
16508 };
16509 diagnostics.push(diagnostic);
16510 }
16511 }
16512 }
16513 processLinkingErrors(document, diagnostics, _options) {
16514 for (const reference of document.references) {
16515 const linkingError = reference.error;
16516 if (linkingError) {
16517 const info = {
16518 node: linkingError.container,
16519 property: linkingError.property,
16520 index: linkingError.index,
16521 data: {
16522 code: DocumentValidator.LinkingError,
16523 containerType: linkingError.container.$type,
16524 property: linkingError.property,
16525 refText: linkingError.reference.$refText
16526 }
16527 };
16528 diagnostics.push(this.toDiagnostic('error', linkingError.message, info));
16529 }
16530 }
16531 }
16532 async validateAst(rootNode, options, cancelToken = cancellation.CancellationToken.None) {
16533 const validationItems = [];
16534 const acceptor = (severity, message, info) => {
16535 validationItems.push(this.toDiagnostic(severity, message, info));
16536 };
16537 await this.validateAstBefore(rootNode, options, acceptor, cancelToken);
16538 await this.validateAstNodes(rootNode, options, acceptor, cancelToken);
16539 await this.validateAstAfter(rootNode, options, acceptor, cancelToken);
16540 return validationItems;
16541 }
16542 async validateAstBefore(rootNode, options, acceptor, cancelToken = cancellation.CancellationToken.None) {
16543 var _a;
16544 const checksBefore = this.validationRegistry.checksBefore;
16545 for (const checkBefore of checksBefore) {
16546 await interruptAndCheck(cancelToken);
16547 await checkBefore(rootNode, acceptor, (_a = options.categories) !== null && _a !== void 0 ? _a : [], cancelToken);
16548 }
16549 }
16550 async validateAstNodes(rootNode, options, acceptor, cancelToken = cancellation.CancellationToken.None) {
16551 await Promise.all((0,ast_utils/* streamAst */.Zc)(rootNode).map(async (node) => {
16552 await interruptAndCheck(cancelToken);
16553 const checks = this.validationRegistry.getChecks(node.$type, options.categories);
16554 for (const check of checks) {
16555 await check(node, acceptor, cancelToken);
16556 }
16557 }));
16558 }
16559 async validateAstAfter(rootNode, options, acceptor, cancelToken = cancellation.CancellationToken.None) {
16560 var _a;
16561 const checksAfter = this.validationRegistry.checksAfter;
16562 for (const checkAfter of checksAfter) {
16563 await interruptAndCheck(cancelToken);
16564 await checkAfter(rootNode, acceptor, (_a = options.categories) !== null && _a !== void 0 ? _a : [], cancelToken);
16565 }
16566 }
16567 toDiagnostic(severity, message, info) {
16568 return {
16569 message,
16570 range: getDiagnosticRange(info),
16571 severity: toDiagnosticSeverity(severity),
16572 code: info.code,
16573 codeDescription: info.codeDescription,
16574 tags: info.tags,
16575 relatedInformation: info.relatedInformation,
16576 data: info.data,
16577 source: this.getSource()
16578 };
16579 }
16580 getSource() {
16581 return this.metadata.languageId;
16582 }
16583 }
16584 function getDiagnosticRange(info) {
16585 if (info.range) {
16586 return info.range;
16587 }
16588 let cstNode;
16589 if (typeof info.property === 'string') {
16590 cstNode = (0,grammar_utils/* findNodeForProperty */.vb)(info.node.$cstNode, info.property, info.index);
16591 }
16592 else if (typeof info.keyword === 'string') {
16593 cstNode = (0,grammar_utils/* findNodeForKeyword */.lA)(info.node.$cstNode, info.keyword, info.index);
16594 }
16595 cstNode !== null && cstNode !== void 0 ? cstNode : (cstNode = info.node.$cstNode);
16596 if (!cstNode) {
16597 return {
16598 start: { line: 0, character: 0 },
16599 end: { line: 0, character: 0 }
16600 };
16601 }
16602 return cstNode.range;
16603 }
16604 /**
16605 * Transforms the diagnostic severity from the {@link LexingDiagnosticSeverity} format to LSP's `DiagnosticSeverity` format.
16606 *
16607 * @param severity The lexing diagnostic severity
16608 * @returns Diagnostic severity according to `vscode-languageserver-types/lib/esm/main.js#DiagnosticSeverity`
16609 */
16610 function toDiagnosticSeverity(severity) {
16611 switch (severity) {
16612 case 'error':
16613 return 1;
16614 case 'warning':
16615 return 2;
16616 case 'info':
16617 return 3;
16618 case 'hint':
16619 return 4;
16620 default:
16621 throw new Error('Invalid diagnostic severity: ' + severity);
16622 }
16623 }
16624 function toDiagnosticData(severity) {
16625 switch (severity) {
16626 case 'error':
16627 return diagnosticData(DocumentValidator.LexingError);
16628 case 'warning':
16629 return diagnosticData(DocumentValidator.LexingWarning);
16630 case 'info':
16631 return diagnosticData(DocumentValidator.LexingInfo);
16632 case 'hint':
16633 return diagnosticData(DocumentValidator.LexingHint);
16634 default:
16635 throw new Error('Invalid diagnostic severity: ' + severity);
16636 }
16637 }
16638 var DocumentValidator;
16639 (function (DocumentValidator) {
16640 DocumentValidator.LexingError = 'lexing-error';
16641 DocumentValidator.LexingWarning = 'lexing-warning';
16642 DocumentValidator.LexingInfo = 'lexing-info';
16643 DocumentValidator.LexingHint = 'lexing-hint';
16644 DocumentValidator.ParsingError = 'parsing-error';
16645 DocumentValidator.LinkingError = 'linking-error';
16646 })(DocumentValidator || (DocumentValidator = {}));
16647 //# sourceMappingURL=document-validator.js.map
16648 ;// CONCATENATED MODULE: ../node_modules/langium/lib/workspace/ast-descriptions.js
16649 /******************************************************************************
16650 * Copyright 2021 TypeFox GmbH
16651 * This program and the accompanying materials are made available under the
16652 * terms of the MIT License, which is available in the project root.
16653 ******************************************************************************/
16654
16655
16656
16657
16658
16659
16660 class DefaultAstNodeDescriptionProvider {
16661 constructor(services) {
16662 this.astNodeLocator = services.workspace.AstNodeLocator;
16663 this.nameProvider = services.references.NameProvider;
16664 }
16665 createDescription(node, name, document) {
16666 const doc = document !== null && document !== void 0 ? document : (0,ast_utils/* getDocument */.Me)(node);
16667 name !== null && name !== void 0 ? name : (name = this.nameProvider.getName(node));
16668 const path = this.astNodeLocator.getAstNodePath(node);
16669 if (!name) {
16670 throw new Error(`Node at path ${path} has no name.`);
16671 }
16672 let nameNodeSegment;
16673 const nameSegmentGetter = () => { var _a; return nameNodeSegment !== null && nameNodeSegment !== void 0 ? nameNodeSegment : (nameNodeSegment = (0,cst_utils/* toDocumentSegment */.yn)((_a = this.nameProvider.getNameNode(node)) !== null && _a !== void 0 ? _a : node.$cstNode)); };
16674 return {
16675 node,
16676 name,
16677 get nameSegment() {
16678 return nameSegmentGetter();
16679 },
16680 selectionSegment: (0,cst_utils/* toDocumentSegment */.yn)(node.$cstNode),
16681 type: node.$type,
16682 documentUri: doc.uri,
16683 path
16684 };
16685 }
16686 }
16687 class DefaultReferenceDescriptionProvider {
16688 constructor(services) {
16689 this.nodeLocator = services.workspace.AstNodeLocator;
16690 }
16691 async createDescriptions(document, cancelToken = cancellation.CancellationToken.None) {
16692 const descr = [];
16693 const rootNode = document.parseResult.value;
16694 for (const astNode of (0,ast_utils/* streamAst */.Zc)(rootNode)) {
16695 await interruptAndCheck(cancelToken);
16696 (0,ast_utils/* streamReferences */.fy)(astNode).filter(refInfo => !(0,syntax_tree/* isLinkingError */.et)(refInfo)).forEach(refInfo => {
16697 // TODO: Consider logging a warning or throw an exception when DocumentState is < than Linked
16698 const description = this.createDescription(refInfo);
16699 if (description) {
16700 descr.push(description);
16701 }
16702 });
16703 }
16704 return descr;
16705 }
16706 createDescription(refInfo) {
16707 const targetNodeDescr = refInfo.reference.$nodeDescription;
16708 const refCstNode = refInfo.reference.$refNode;
16709 if (!targetNodeDescr || !refCstNode) {
16710 return undefined;
16711 }
16712 const docUri = (0,ast_utils/* getDocument */.Me)(refInfo.container).uri;
16713 return {
16714 sourceUri: docUri,
16715 sourcePath: this.nodeLocator.getAstNodePath(refInfo.container),
16716 targetUri: targetNodeDescr.documentUri,
16717 targetPath: targetNodeDescr.path,
16718 segment: (0,cst_utils/* toDocumentSegment */.yn)(refCstNode),
16719 local: UriUtils.equals(targetNodeDescr.documentUri, docUri)
16720 };
16721 }
16722 }
16723 //# sourceMappingURL=ast-descriptions.js.map
16724 ;// CONCATENATED MODULE: ../node_modules/langium/lib/workspace/ast-node-locator.js
16725 /******************************************************************************
16726 * Copyright 2021 TypeFox GmbH
16727 * This program and the accompanying materials are made available under the
16728 * terms of the MIT License, which is available in the project root.
16729 ******************************************************************************/
16730 class DefaultAstNodeLocator {
16731 constructor() {
16732 this.segmentSeparator = '/';
16733 this.indexSeparator = '@';
16734 }
16735 getAstNodePath(node) {
16736 if (node.$container) {
16737 const containerPath = this.getAstNodePath(node.$container);
16738 const newSegment = this.getPathSegment(node);
16739 const nodePath = containerPath + this.segmentSeparator + newSegment;
16740 return nodePath;
16741 }
16742 return '';
16743 }
16744 getPathSegment({ $containerProperty, $containerIndex }) {
16745 if (!$containerProperty) {
16746 throw new Error("Missing '$containerProperty' in AST node.");
16747 }
16748 if ($containerIndex !== undefined) {
16749 return $containerProperty + this.indexSeparator + $containerIndex;
16750 }
16751 return $containerProperty;
16752 }
16753 getAstNode(node, path) {
16754 const segments = path.split(this.segmentSeparator);
16755 return segments.reduce((previousValue, currentValue) => {
16756 if (!previousValue || currentValue.length === 0) {
16757 return previousValue;
16758 }
16759 const propertyIndex = currentValue.indexOf(this.indexSeparator);
16760 if (propertyIndex > 0) {
16761 const property = currentValue.substring(0, propertyIndex);
16762 const arrayIndex = parseInt(currentValue.substring(propertyIndex + 1));
16763 const array = previousValue[property];
16764 return array === null || array === void 0 ? void 0 : array[arrayIndex];
16765 }
16766 return previousValue[currentValue];
16767 }, node);
16768 }
16769 }
16770 //# sourceMappingURL=ast-node-locator.js.map
16771 // EXTERNAL MODULE: ../node_modules/vscode-jsonrpc/lib/common/events.js
16772 var events = __webpack_require__(345);
16773 ;// CONCATENATED MODULE: ../node_modules/langium/lib/workspace/configuration.js
16774 /******************************************************************************
16775 * Copyright 2022 TypeFox GmbH
16776 * This program and the accompanying materials are made available under the
16777 * terms of the MIT License, which is available in the project root.
16778 ******************************************************************************/
16779
16780
16781 /**
16782 * Base configuration provider for building up other configuration providers
16783 */
16784 class DefaultConfigurationProvider {
16785 constructor(services) {
16786 this._ready = new promise_utils_Deferred();
16787 this.settings = {};
16788 this.workspaceConfig = false;
16789 this.onConfigurationSectionUpdateEmitter = new events.Emitter();
16790 this.serviceRegistry = services.ServiceRegistry;
16791 }
16792 get ready() {
16793 return this._ready.promise;
16794 }
16795 initialize(params) {
16796 var _a, _b;
16797 this.workspaceConfig = (_b = (_a = params.capabilities.workspace) === null || _a === void 0 ? void 0 : _a.configuration) !== null && _b !== void 0 ? _b : false;
16798 }
16799 async initialized(params) {
16800 if (this.workspaceConfig) {
16801 if (params.register) {
16802 // params.register(...) is a function to be provided by the calling language server for the sake of
16803 // decoupling this implementation from the concrete LSP implementations, specifically the LSP Connection
16804 const languages = this.serviceRegistry.all;
16805 params.register({
16806 // Listen to configuration changes for all languages
16807 section: languages.map(lang => this.toSectionName(lang.LanguageMetaData.languageId))
16808 });
16809 }
16810 if (params.fetchConfiguration) {
16811 // params.fetchConfiguration(...) is a function to be provided by the calling language server for the sake of
16812 // decoupling this implementation from the concrete LSP implementations, specifically the LSP Connection
16813 const configToUpdate = this.serviceRegistry.all.map(lang => ({
16814 // Fetch the configuration changes for all languages
16815 section: this.toSectionName(lang.LanguageMetaData.languageId)
16816 }));
16817 // get workspace configurations (default scope URI)
16818 const configs = await params.fetchConfiguration(configToUpdate);
16819 configToUpdate.forEach((conf, idx) => {
16820 this.updateSectionConfiguration(conf.section, configs[idx]);
16821 });
16822 }
16823 }
16824 this._ready.resolve();
16825 }
16826 /**
16827 * Updates the cached configurations using the `change` notification parameters.
16828 *
16829 * @param change The parameters of a change configuration notification.
16830 * `settings` property of the change object could be expressed as `Record<string, Record<string, any>>`
16831 */
16832 updateConfiguration(change) {
16833 if (!change.settings) {
16834 return;
16835 }
16836 Object.keys(change.settings).forEach(section => {
16837 const configuration = change.settings[section];
16838 this.updateSectionConfiguration(section, configuration);
16839 this.onConfigurationSectionUpdateEmitter.fire({ section, configuration });
16840 });
16841 }
16842 updateSectionConfiguration(section, configuration) {
16843 this.settings[section] = configuration;
16844 }
16845 /**
16846 * Returns a configuration value stored for the given language.
16847 *
16848 * @param language The language id
16849 * @param configuration Configuration name
16850 */
16851 async getConfiguration(language, configuration) {
16852 await this.ready;
16853 const sectionName = this.toSectionName(language);
16854 if (this.settings[sectionName]) {
16855 return this.settings[sectionName][configuration];
16856 }
16857 }
16858 toSectionName(languageId) {
16859 return `${languageId}`;
16860 }
16861 get onConfigurationSectionUpdate() {
16862 return this.onConfigurationSectionUpdateEmitter.event;
16863 }
16864 }
16865 //# sourceMappingURL=configuration.js.map
16866 ;// CONCATENATED MODULE: ../node_modules/langium/lib/utils/disposable.js
16867 /******************************************************************************
16868 * Copyright 2021 TypeFox GmbH
16869 * This program and the accompanying materials are made available under the
16870 * terms of the MIT License, which is available in the project root.
16871 ******************************************************************************/
16872 var Disposable;
16873 (function (Disposable) {
16874 function create(callback) {
16875 return {
16876 dispose: async () => await callback()
16877 };
16878 }
16879 Disposable.create = create;
16880 })(Disposable || (Disposable = {}));
16881 //# sourceMappingURL=disposable.js.map
16882 ;// CONCATENATED MODULE: ../node_modules/langium/lib/workspace/document-builder.js
16883 /******************************************************************************
16884 * Copyright 2021 TypeFox GmbH
16885 * This program and the accompanying materials are made available under the
16886 * terms of the MIT License, which is available in the project root.
16887 ******************************************************************************/
16888
16889
16890
16891
16892
16893
16894
16895 class DefaultDocumentBuilder {
16896 constructor(services) {
16897 this.updateBuildOptions = {
16898 // Default: run only the built-in validation checks and those in the _fast_ category (includes those without category)
16899 validation: {
16900 categories: ['built-in', 'fast']
16901 }
16902 };
16903 this.updateListeners = [];
16904 this.buildPhaseListeners = new MultiMap();
16905 this.documentPhaseListeners = new MultiMap();
16906 this.buildState = new Map();
16907 this.documentBuildWaiters = new Map();
16908 this.currentState = DocumentState.Changed;
16909 this.langiumDocuments = services.workspace.LangiumDocuments;
16910 this.langiumDocumentFactory = services.workspace.LangiumDocumentFactory;
16911 this.textDocuments = services.workspace.TextDocuments;
16912 this.indexManager = services.workspace.IndexManager;
16913 this.serviceRegistry = services.ServiceRegistry;
16914 }
16915 async build(documents, options = {}, cancelToken = cancellation.CancellationToken.None) {
16916 var _a, _b;
16917 for (const document of documents) {
16918 const key = document.uri.toString();
16919 if (document.state === DocumentState.Validated) {
16920 if (typeof options.validation === 'boolean' && options.validation) {
16921 // Force re-running all validation checks
16922 document.state = DocumentState.IndexedReferences;
16923 document.diagnostics = undefined;
16924 this.buildState.delete(key);
16925 }
16926 else if (typeof options.validation === 'object') {
16927 const buildState = this.buildState.get(key);
16928 const previousCategories = (_a = buildState === null || buildState === void 0 ? void 0 : buildState.result) === null || _a === void 0 ? void 0 : _a.validationChecks;
16929 if (previousCategories) {
16930 // Validation with explicit options was requested for a document that has already been partly validated.
16931 // In this case, we need to merge the previous validation categories with the new ones.
16932 const newCategories = (_b = options.validation.categories) !== null && _b !== void 0 ? _b : ValidationCategory.all;
16933 const categories = newCategories.filter(c => !previousCategories.includes(c));
16934 if (categories.length > 0) {
16935 this.buildState.set(key, {
16936 completed: false,
16937 options: {
16938 validation: Object.assign(Object.assign({}, options.validation), { categories })
16939 },
16940 result: buildState.result
16941 });
16942 document.state = DocumentState.IndexedReferences;
16943 }
16944 }
16945 }
16946 }
16947 else {
16948 // Default: forget any previous build options
16949 this.buildState.delete(key);
16950 }
16951 }
16952 this.currentState = DocumentState.Changed;
16953 await this.emitUpdate(documents.map(e => e.uri), []);
16954 await this.buildDocuments(documents, options, cancelToken);
16955 }
16956 async update(changed, deleted, cancelToken = cancellation.CancellationToken.None) {
16957 this.currentState = DocumentState.Changed;
16958 // Remove all metadata of documents that are reported as deleted
16959 for (const deletedUri of deleted) {
16960 this.langiumDocuments.deleteDocument(deletedUri);
16961 this.buildState.delete(deletedUri.toString());
16962 this.indexManager.remove(deletedUri);
16963 }
16964 // Set the state of all changed documents to `Changed` so they are completely rebuilt
16965 for (const changedUri of changed) {
16966 const invalidated = this.langiumDocuments.invalidateDocument(changedUri);
16967 if (!invalidated) {
16968 // We create an unparsed, invalid document.
16969 // This will be parsed as soon as we reach the first document builder phase.
16970 // This allows to cancel the parsing process later in case we need it.
16971 const newDocument = this.langiumDocumentFactory.fromModel({ $type: 'INVALID' }, changedUri);
16972 newDocument.state = DocumentState.Changed;
16973 this.langiumDocuments.addDocument(newDocument);
16974 }
16975 this.buildState.delete(changedUri.toString());
16976 }
16977 // Set the state of all documents that should be relinked to `ComputedScopes` (if not already lower)
16978 const allChangedUris = (0,stream/* stream */.Vw)(changed).concat(deleted).map(uri => uri.toString()).toSet();
16979 this.langiumDocuments.all
16980 .filter(doc => !allChangedUris.has(doc.uri.toString()) && this.shouldRelink(doc, allChangedUris))
16981 .forEach(doc => {
16982 const linker = this.serviceRegistry.getServices(doc.uri).references.Linker;
16983 linker.unlink(doc);
16984 doc.state = Math.min(doc.state, DocumentState.ComputedScopes);
16985 doc.diagnostics = undefined;
16986 });
16987 // Notify listeners of the update
16988 await this.emitUpdate(changed, deleted);
16989 // Only allow interrupting the execution after all state changes are done
16990 await interruptAndCheck(cancelToken);
16991 // Collect and sort all documents that we should rebuild
16992 const rebuildDocuments = this.sortDocuments(this.langiumDocuments.all
16993 .filter(doc => {
16994 var _a;
16995 // This includes those that were reported as changed and those that we selected for relinking
16996 return doc.state < DocumentState.Linked
16997 // This includes those for which a previous build has been cancelled
16998 || !((_a = this.buildState.get(doc.uri.toString())) === null || _a === void 0 ? void 0 : _a.completed);
16999 })
17000 .toArray());
17001 await this.buildDocuments(rebuildDocuments, this.updateBuildOptions, cancelToken);
17002 }
17003 async emitUpdate(changed, deleted) {
17004 await Promise.all(this.updateListeners.map(listener => listener(changed, deleted)));
17005 }
17006 /**
17007 * Sort the given documents by priority. By default, documents with an open text document are prioritized.
17008 * This is useful to ensure that visible documents show their diagnostics before all other documents.
17009 *
17010 * This improves the responsiveness in large workspaces as users usually don't care about diagnostics
17011 * in files that are currently not opened in the editor.
17012 */
17013 sortDocuments(documents) {
17014 let left = 0;
17015 let right = documents.length - 1;
17016 while (left < right) {
17017 while (left < documents.length && this.hasTextDocument(documents[left])) {
17018 left++;
17019 }
17020 while (right >= 0 && !this.hasTextDocument(documents[right])) {
17021 right--;
17022 }
17023 if (left < right) {
17024 [documents[left], documents[right]] = [documents[right], documents[left]];
17025 }
17026 }
17027 return documents;
17028 }
17029 hasTextDocument(doc) {
17030 var _a;
17031 return Boolean((_a = this.textDocuments) === null || _a === void 0 ? void 0 : _a.get(doc.uri));
17032 }
17033 /**
17034 * Check whether the given document should be relinked after changes were found in the given URIs.
17035 */
17036 shouldRelink(document, changedUris) {
17037 // Relink documents with linking errors -- maybe those references can be resolved now
17038 if (document.references.some(ref => ref.error !== undefined)) {
17039 return true;
17040 }
17041 // Check whether the document is affected by any of the changed URIs
17042 return this.indexManager.isAffected(document, changedUris);
17043 }
17044 onUpdate(callback) {
17045 this.updateListeners.push(callback);
17046 return Disposable.create(() => {
17047 const index = this.updateListeners.indexOf(callback);
17048 if (index >= 0) {
17049 this.updateListeners.splice(index, 1);
17050 }
17051 });
17052 }
17053 /**
17054 * Build the given documents by stepping through all build phases. If a document's state indicates
17055 * that a certain build phase is already done, the phase is skipped for that document.
17056 *
17057 * @param documents The documents to build.
17058 * @param options the {@link BuildOptions} to use.
17059 * @param cancelToken A cancellation token that can be used to cancel the build.
17060 * @returns A promise that resolves when the build is done.
17061 */
17062 async buildDocuments(documents, options, cancelToken) {
17063 this.prepareBuild(documents, options);
17064 // 0. Parse content
17065 await this.runCancelable(documents, DocumentState.Parsed, cancelToken, doc => this.langiumDocumentFactory.update(doc, cancelToken));
17066 // 1. Index content
17067 await this.runCancelable(documents, DocumentState.IndexedContent, cancelToken, doc => this.indexManager.updateContent(doc, cancelToken));
17068 // 2. Compute scopes
17069 await this.runCancelable(documents, DocumentState.ComputedScopes, cancelToken, async (doc) => {
17070 const scopeComputation = this.serviceRegistry.getServices(doc.uri).references.ScopeComputation;
17071 doc.precomputedScopes = await scopeComputation.computeLocalScopes(doc, cancelToken);
17072 });
17073 // 3. Linking
17074 await this.runCancelable(documents, DocumentState.Linked, cancelToken, doc => {
17075 const linker = this.serviceRegistry.getServices(doc.uri).references.Linker;
17076 return linker.link(doc, cancelToken);
17077 });
17078 // 4. Index references
17079 await this.runCancelable(documents, DocumentState.IndexedReferences, cancelToken, doc => this.indexManager.updateReferences(doc, cancelToken));
17080 // 5. Validation
17081 const toBeValidated = documents.filter(doc => this.shouldValidate(doc));
17082 await this.runCancelable(toBeValidated, DocumentState.Validated, cancelToken, doc => this.validate(doc, cancelToken));
17083 // If we've made it to this point without being cancelled, we can mark the build state as completed.
17084 for (const doc of documents) {
17085 const state = this.buildState.get(doc.uri.toString());
17086 if (state) {
17087 state.completed = true;
17088 }
17089 }
17090 }
17091 /**
17092 * Runs prior to beginning the build process to update the {@link DocumentBuildState} for each document
17093 *
17094 * @param documents collection of documents to be built
17095 * @param options the {@link BuildOptions} to use
17096 */
17097 prepareBuild(documents, options) {
17098 for (const doc of documents) {
17099 const key = doc.uri.toString();
17100 const state = this.buildState.get(key);
17101 // If the document has no previous build state, we set it. If it has one, but it's already marked
17102 // as completed, we overwrite it. If the previous build was not completed, we keep its state
17103 // and continue where it was cancelled.
17104 if (!state || state.completed) {
17105 this.buildState.set(key, {
17106 completed: false,
17107 options,
17108 result: state === null || state === void 0 ? void 0 : state.result
17109 });
17110 }
17111 }
17112 }
17113 /**
17114 * Runs a cancelable operation on a set of documents to bring them to a specified {@link DocumentState}.
17115 *
17116 * @param documents The array of documents to process.
17117 * @param targetState The target {@link DocumentState} to bring the documents to.
17118 * @param cancelToken A token that can be used to cancel the operation.
17119 * @param callback A function to be called for each document.
17120 * @returns A promise that resolves when all documents have been processed or the operation is canceled.
17121 * @throws Will throw `OperationCancelled` if the operation is canceled via a `CancellationToken`.
17122 */
17123 async runCancelable(documents, targetState, cancelToken, callback) {
17124 const filtered = documents.filter(doc => doc.state < targetState);
17125 for (const document of filtered) {
17126 await interruptAndCheck(cancelToken);
17127 await callback(document);
17128 document.state = targetState;
17129 await this.notifyDocumentPhase(document, targetState, cancelToken);
17130 }
17131 // Do not use `filtered` here, as that will miss documents that have previously reached the current target state
17132 // For example, this happens in case the cancellation triggers between the processing of two documents
17133 // Or files that were picked up during the workspace initialization
17134 const targetStateDocs = documents.filter(doc => doc.state === targetState);
17135 await this.notifyBuildPhase(targetStateDocs, targetState, cancelToken);
17136 this.currentState = targetState;
17137 }
17138 onBuildPhase(targetState, callback) {
17139 this.buildPhaseListeners.add(targetState, callback);
17140 return Disposable.create(() => {
17141 this.buildPhaseListeners.delete(targetState, callback);
17142 });
17143 }
17144 onDocumentPhase(targetState, callback) {
17145 this.documentPhaseListeners.add(targetState, callback);
17146 return Disposable.create(() => {
17147 this.documentPhaseListeners.delete(targetState, callback);
17148 });
17149 }
17150 waitUntil(state, uriOrToken, cancelToken) {
17151 let uri = undefined;
17152 if (uriOrToken && 'path' in uriOrToken) {
17153 uri = uriOrToken;
17154 }
17155 else {
17156 cancelToken = uriOrToken;
17157 }
17158 cancelToken !== null && cancelToken !== void 0 ? cancelToken : (cancelToken = cancellation.CancellationToken.None);
17159 if (uri) {
17160 const document = this.langiumDocuments.getDocument(uri);
17161 if (document && document.state > state) {
17162 return Promise.resolve(uri);
17163 }
17164 }
17165 if (this.currentState >= state) {
17166 return Promise.resolve(undefined);
17167 }
17168 else if (cancelToken.isCancellationRequested) {
17169 return Promise.reject(promise_utils_OperationCancelled);
17170 }
17171 return new Promise((resolve, reject) => {
17172 const buildDisposable = this.onBuildPhase(state, () => {
17173 buildDisposable.dispose();
17174 cancelDisposable.dispose();
17175 if (uri) {
17176 const document = this.langiumDocuments.getDocument(uri);
17177 resolve(document === null || document === void 0 ? void 0 : document.uri);
17178 }
17179 else {
17180 resolve(undefined);
17181 }
17182 });
17183 const cancelDisposable = cancelToken.onCancellationRequested(() => {
17184 buildDisposable.dispose();
17185 cancelDisposable.dispose();
17186 reject(promise_utils_OperationCancelled);
17187 });
17188 });
17189 }
17190 async notifyDocumentPhase(document, state, cancelToken) {
17191 const listeners = this.documentPhaseListeners.get(state);
17192 const listenersCopy = listeners.slice();
17193 for (const listener of listenersCopy) {
17194 try {
17195 await listener(document, cancelToken);
17196 }
17197 catch (err) {
17198 // Ignore cancellation errors
17199 // We want to finish the listeners before throwing
17200 if (!isOperationCancelled(err)) {
17201 throw err;
17202 }
17203 }
17204 }
17205 }
17206 async notifyBuildPhase(documents, state, cancelToken) {
17207 if (documents.length === 0) {
17208 // Don't notify when no document has been processed
17209 return;
17210 }
17211 const listeners = this.buildPhaseListeners.get(state);
17212 const listenersCopy = listeners.slice();
17213 for (const listener of listenersCopy) {
17214 await interruptAndCheck(cancelToken);
17215 await listener(documents, cancelToken);
17216 }
17217 }
17218 /**
17219 * Determine whether the given document should be validated during a build. The default
17220 * implementation checks the `validation` property of the build options. If it's set to `true`
17221 * or a `ValidationOptions` object, the document is included in the validation phase.
17222 */
17223 shouldValidate(document) {
17224 return Boolean(this.getBuildOptions(document).validation);
17225 }
17226 /**
17227 * Run validation checks on the given document and store the resulting diagnostics in the document.
17228 * If the document already contains diagnostics, the new ones are added to the list.
17229 */
17230 async validate(document, cancelToken) {
17231 var _a, _b;
17232 const validator = this.serviceRegistry.getServices(document.uri).validation.DocumentValidator;
17233 const validationSetting = this.getBuildOptions(document).validation;
17234 const options = typeof validationSetting === 'object' ? validationSetting : undefined;
17235 const diagnostics = await validator.validateDocument(document, options, cancelToken);
17236 if (document.diagnostics) {
17237 document.diagnostics.push(...diagnostics);
17238 }
17239 else {
17240 document.diagnostics = diagnostics;
17241 }
17242 // Store information about the executed validation in the build state
17243 const state = this.buildState.get(document.uri.toString());
17244 if (state) {
17245 (_a = state.result) !== null && _a !== void 0 ? _a : (state.result = {});
17246 const newCategories = (_b = options === null || options === void 0 ? void 0 : options.categories) !== null && _b !== void 0 ? _b : ValidationCategory.all;
17247 if (state.result.validationChecks) {
17248 state.result.validationChecks.push(...newCategories);
17249 }
17250 else {
17251 state.result.validationChecks = [...newCategories];
17252 }
17253 }
17254 }
17255 getBuildOptions(document) {
17256 var _a, _b;
17257 return (_b = (_a = this.buildState.get(document.uri.toString())) === null || _a === void 0 ? void 0 : _a.options) !== null && _b !== void 0 ? _b : {};
17258 }
17259 }
17260 //# sourceMappingURL=document-builder.js.map
17261 ;// CONCATENATED MODULE: ../node_modules/langium/lib/workspace/index-manager.js
17262 /******************************************************************************
17263 * Copyright 2021 TypeFox GmbH
17264 * This program and the accompanying materials are made available under the
17265 * terms of the MIT License, which is available in the project root.
17266 ******************************************************************************/
17267
17268
17269
17270
17271
17272 class DefaultIndexManager {
17273 constructor(services) {
17274 /**
17275 * The symbol index stores all `AstNodeDescription` items exported by a document.
17276 * The key used in this map is the string representation of the specific document URI.
17277 */
17278 this.symbolIndex = new Map();
17279 /**
17280 * This is a cache for the `allElements()` method.
17281 * It caches the descriptions from `symbolIndex` grouped by types.
17282 */
17283 this.symbolByTypeIndex = new ContextCache();
17284 /**
17285 * This index keeps track of all `ReferenceDescription` items exported by a document.
17286 * This is used to compute which elements are affected by a document change
17287 * and for finding references to an AST node.
17288 */
17289 this.referenceIndex = new Map();
17290 this.documents = services.workspace.LangiumDocuments;
17291 this.serviceRegistry = services.ServiceRegistry;
17292 this.astReflection = services.AstReflection;
17293 }
17294 findAllReferences(targetNode, astNodePath) {
17295 const targetDocUri = (0,ast_utils/* getDocument */.Me)(targetNode).uri;
17296 const result = [];
17297 this.referenceIndex.forEach(docRefs => {
17298 docRefs.forEach(refDescr => {
17299 if (UriUtils.equals(refDescr.targetUri, targetDocUri) && refDescr.targetPath === astNodePath) {
17300 result.push(refDescr);
17301 }
17302 });
17303 });
17304 return (0,stream/* stream */.Vw)(result);
17305 }
17306 allElements(nodeType, uris) {
17307 let documentUris = (0,stream/* stream */.Vw)(this.symbolIndex.keys());
17308 if (uris) {
17309 documentUris = documentUris.filter(uri => !uris || uris.has(uri));
17310 }
17311 return documentUris
17312 .map(uri => this.getFileDescriptions(uri, nodeType))
17313 .flat();
17314 }
17315 getFileDescriptions(uri, nodeType) {
17316 var _a;
17317 if (!nodeType) {
17318 return (_a = this.symbolIndex.get(uri)) !== null && _a !== void 0 ? _a : [];
17319 }
17320 const descriptions = this.symbolByTypeIndex.get(uri, nodeType, () => {
17321 var _a;
17322 const allFileDescriptions = (_a = this.symbolIndex.get(uri)) !== null && _a !== void 0 ? _a : [];
17323 return allFileDescriptions.filter(e => this.astReflection.isSubtype(e.type, nodeType));
17324 });
17325 return descriptions;
17326 }
17327 remove(uri) {
17328 const uriString = uri.toString();
17329 this.symbolIndex.delete(uriString);
17330 this.symbolByTypeIndex.clear(uriString);
17331 this.referenceIndex.delete(uriString);
17332 }
17333 async updateContent(document, cancelToken = cancellation.CancellationToken.None) {
17334 const services = this.serviceRegistry.getServices(document.uri);
17335 const exports = await services.references.ScopeComputation.computeExports(document, cancelToken);
17336 const uri = document.uri.toString();
17337 this.symbolIndex.set(uri, exports);
17338 this.symbolByTypeIndex.clear(uri);
17339 }
17340 async updateReferences(document, cancelToken = cancellation.CancellationToken.None) {
17341 const services = this.serviceRegistry.getServices(document.uri);
17342 const indexData = await services.workspace.ReferenceDescriptionProvider.createDescriptions(document, cancelToken);
17343 this.referenceIndex.set(document.uri.toString(), indexData);
17344 }
17345 isAffected(document, changedUris) {
17346 const references = this.referenceIndex.get(document.uri.toString());
17347 if (!references) {
17348 return false;
17349 }
17350 return references.some(ref => !ref.local && changedUris.has(ref.targetUri.toString()));
17351 }
17352 }
17353 //# sourceMappingURL=index-manager.js.map
17354 ;// CONCATENATED MODULE: ../node_modules/langium/lib/workspace/workspace-manager.js
17355 /******************************************************************************
17356 * Copyright 2022 TypeFox GmbH
17357 * This program and the accompanying materials are made available under the
17358 * terms of the MIT License, which is available in the project root.
17359 ******************************************************************************/
17360
17361
17362
17363 class DefaultWorkspaceManager {
17364 constructor(services) {
17365 this.initialBuildOptions = {};
17366 this._ready = new promise_utils_Deferred();
17367 this.serviceRegistry = services.ServiceRegistry;
17368 this.langiumDocuments = services.workspace.LangiumDocuments;
17369 this.documentBuilder = services.workspace.DocumentBuilder;
17370 this.fileSystemProvider = services.workspace.FileSystemProvider;
17371 this.mutex = services.workspace.WorkspaceLock;
17372 }
17373 get ready() {
17374 return this._ready.promise;
17375 }
17376 get workspaceFolders() {
17377 return this.folders;
17378 }
17379 initialize(params) {
17380 var _a;
17381 this.folders = (_a = params.workspaceFolders) !== null && _a !== void 0 ? _a : undefined;
17382 }
17383 initialized(_params) {
17384 // Initialize the workspace even if there are no workspace folders
17385 // We still want to load additional documents (language library or similar) during initialization
17386 return this.mutex.write(token => { var _a; return this.initializeWorkspace((_a = this.folders) !== null && _a !== void 0 ? _a : [], token); });
17387 }
17388 async initializeWorkspace(folders, cancelToken = cancellation.CancellationToken.None) {
17389 const documents = await this.performStartup(folders);
17390 // Only after creating all documents do we check whether we need to cancel the initialization
17391 // The document builder will later pick up on all unprocessed documents
17392 await interruptAndCheck(cancelToken);
17393 await this.documentBuilder.build(documents, this.initialBuildOptions, cancelToken);
17394 }
17395 /**
17396 * Performs the uninterruptable startup sequence of the workspace manager.
17397 * This methods loads all documents in the workspace and other documents and returns them.
17398 */
17399 async performStartup(folders) {
17400 const fileExtensions = this.serviceRegistry.all.flatMap(e => e.LanguageMetaData.fileExtensions);
17401 const documents = [];
17402 const collector = (document) => {
17403 documents.push(document);
17404 if (!this.langiumDocuments.hasDocument(document.uri)) {
17405 this.langiumDocuments.addDocument(document);
17406 }
17407 };
17408 // Even though we don't await the initialization of the workspace manager,
17409 // we can still assume that all library documents and file documents are loaded by the time we start building documents.
17410 // The mutex prevents anything from performing a workspace build until we check the cancellation token
17411 await this.loadAdditionalDocuments(folders, collector);
17412 await Promise.all(folders.map(wf => [wf, this.getRootFolder(wf)])
17413 .map(async (entry) => this.traverseFolder(...entry, fileExtensions, collector)));
17414 this._ready.resolve();
17415 return documents;
17416 }
17417 /**
17418 * Load all additional documents that shall be visible in the context of the given workspace
17419 * folders and add them to the collector. This can be used to include built-in libraries of
17420 * your language, which can be either loaded from provided files or constructed in memory.
17421 */
17422 loadAdditionalDocuments(_folders, _collector) {
17423 return Promise.resolve();
17424 }
17425 /**
17426 * Determine the root folder of the source documents in the given workspace folder.
17427 * The default implementation returns the URI of the workspace folder, but you can override
17428 * this to return a subfolder like `src` instead.
17429 */
17430 getRootFolder(workspaceFolder) {
17431 return esm/* URI */.o.parse(workspaceFolder.uri);
17432 }
17433 /**
17434 * Traverse the file system folder identified by the given URI and its subfolders. All
17435 * contained files that match the file extensions are added to the collector.
17436 */
17437 async traverseFolder(workspaceFolder, folderPath, fileExtensions, collector) {
17438 const content = await this.fileSystemProvider.readDirectory(folderPath);
17439 await Promise.all(content.map(async (entry) => {
17440 if (this.includeEntry(workspaceFolder, entry, fileExtensions)) {
17441 if (entry.isDirectory) {
17442 await this.traverseFolder(workspaceFolder, entry.uri, fileExtensions, collector);
17443 }
17444 else if (entry.isFile) {
17445 const document = await this.langiumDocuments.getOrCreateDocument(entry.uri);
17446 collector(document);
17447 }
17448 }
17449 }));
17450 }
17451 /**
17452 * Determine whether the given folder entry shall be included while indexing the workspace.
17453 */
17454 includeEntry(_workspaceFolder, entry, fileExtensions) {
17455 const name = UriUtils.basename(entry.uri);
17456 if (name.startsWith('.')) {
17457 return false;
17458 }
17459 if (entry.isDirectory) {
17460 return name !== 'node_modules' && name !== 'out';
17461 }
17462 else if (entry.isFile) {
17463 const extname = UriUtils.extname(entry.uri);
17464 return fileExtensions.includes(extname);
17465 }
17466 return false;
17467 }
17468 }
17469 //# sourceMappingURL=workspace-manager.js.map
17470 ;// CONCATENATED MODULE: ../node_modules/langium/lib/parser/lexer.js
17471 /******************************************************************************
17472 * Copyright 2022 TypeFox GmbH
17473 * This program and the accompanying materials are made available under the
17474 * terms of the MIT License, which is available in the project root.
17475 ******************************************************************************/
17476
17477 class DefaultLexerErrorMessageProvider {
17478 buildUnexpectedCharactersMessage(fullText, startOffset, length, line, column) {
17479 return api/* defaultLexerErrorProvider */.ZW.buildUnexpectedCharactersMessage(fullText, startOffset, length, line, column);
17480 }
17481 buildUnableToPopLexerModeMessage(token) {
17482 return api/* defaultLexerErrorProvider */.ZW.buildUnableToPopLexerModeMessage(token);
17483 }
17484 }
17485 const DEFAULT_TOKENIZE_OPTIONS = { mode: 'full' };
17486 class DefaultLexer {
17487 constructor(services) {
17488 this.errorMessageProvider = services.parser.LexerErrorMessageProvider;
17489 this.tokenBuilder = services.parser.TokenBuilder;
17490 const tokens = this.tokenBuilder.buildTokens(services.Grammar, {
17491 caseInsensitive: services.LanguageMetaData.caseInsensitive
17492 });
17493 this.tokenTypes = this.toTokenTypeDictionary(tokens);
17494 const lexerTokens = isTokenTypeDictionary(tokens) ? Object.values(tokens) : tokens;
17495 const production = services.LanguageMetaData.mode === 'production';
17496 this.chevrotainLexer = new api/* Lexer */.hW(lexerTokens, {
17497 positionTracking: 'full',
17498 skipValidations: production,
17499 errorMessageProvider: this.errorMessageProvider
17500 });
17501 }
17502 get definition() {
17503 return this.tokenTypes;
17504 }
17505 tokenize(text, _options = DEFAULT_TOKENIZE_OPTIONS) {
17506 var _a, _b, _c;
17507 const chevrotainResult = this.chevrotainLexer.tokenize(text);
17508 return {
17509 tokens: chevrotainResult.tokens,
17510 errors: chevrotainResult.errors,
17511 hidden: (_a = chevrotainResult.groups.hidden) !== null && _a !== void 0 ? _a : [],
17512 report: (_c = (_b = this.tokenBuilder).flushLexingReport) === null || _c === void 0 ? void 0 : _c.call(_b, text)
17513 };
17514 }
17515 toTokenTypeDictionary(buildTokens) {
17516 if (isTokenTypeDictionary(buildTokens))
17517 return buildTokens;
17518 const tokens = isIMultiModeLexerDefinition(buildTokens) ? Object.values(buildTokens.modes).flat() : buildTokens;
17519 const res = {};
17520 tokens.forEach(token => res[token.name] = token);
17521 return res;
17522 }
17523 }
17524 /**
17525 * Returns a check whether the given TokenVocabulary is TokenType array
17526 */
17527 function isTokenTypeArray(tokenVocabulary) {
17528 return Array.isArray(tokenVocabulary) && (tokenVocabulary.length === 0 || 'name' in tokenVocabulary[0]);
17529 }
17530 /**
17531 * Returns a check whether the given TokenVocabulary is IMultiModeLexerDefinition
17532 */
17533 function isIMultiModeLexerDefinition(tokenVocabulary) {
17534 return tokenVocabulary && 'modes' in tokenVocabulary && 'defaultMode' in tokenVocabulary;
17535 }
17536 /**
17537 * Returns a check whether the given TokenVocabulary is TokenTypeDictionary
17538 */
17539 function isTokenTypeDictionary(tokenVocabulary) {
17540 return !isTokenTypeArray(tokenVocabulary) && !isIMultiModeLexerDefinition(tokenVocabulary);
17541 }
17542 //# sourceMappingURL=lexer.js.map
17543 ;// CONCATENATED MODULE: ../node_modules/langium/lib/documentation/jsdoc.js
17544 /******************************************************************************
17545 * Copyright 2023 TypeFox GmbH
17546 * This program and the accompanying materials are made available under the
17547 * terms of the MIT License, which is available in the project root.
17548 ******************************************************************************/
17549
17550
17551
17552 function parseJSDoc(node, start, options) {
17553 let opts;
17554 let position;
17555 if (typeof node === 'string') {
17556 position = start;
17557 opts = options;
17558 }
17559 else {
17560 position = node.range.start;
17561 opts = start;
17562 }
17563 if (!position) {
17564 position = Position.create(0, 0);
17565 }
17566 const lines = getLines(node);
17567 const normalizedOptions = normalizeOptions(opts);
17568 const tokens = tokenize({
17569 lines,
17570 position,
17571 options: normalizedOptions
17572 });
17573 return parseJSDocComment({
17574 index: 0,
17575 tokens,
17576 position
17577 });
17578 }
17579 function isJSDoc(node, options) {
17580 const normalizedOptions = normalizeOptions(options);
17581 const lines = getLines(node);
17582 if (lines.length === 0) {
17583 return false;
17584 }
17585 const first = lines[0];
17586 const last = lines[lines.length - 1];
17587 const firstRegex = normalizedOptions.start;
17588 const lastRegex = normalizedOptions.end;
17589 return Boolean(firstRegex === null || firstRegex === void 0 ? void 0 : firstRegex.exec(first)) && Boolean(lastRegex === null || lastRegex === void 0 ? void 0 : lastRegex.exec(last));
17590 }
17591 function getLines(node) {
17592 let content = '';
17593 if (typeof node === 'string') {
17594 content = node;
17595 }
17596 else {
17597 content = node.text;
17598 }
17599 const lines = content.split(regexp_utils/* NEWLINE_REGEXP */.K0);
17600 return lines;
17601 }
17602 const tagRegex = /\s*(@([\p{L}][\p{L}\p{N}]*)?)/uy;
17603 const inlineTagRegex = /\{(@[\p{L}][\p{L}\p{N}]*)(\s*)([^\r\n}]+)?\}/gu;
17604 function tokenize(context) {
17605 var _a, _b, _c;
17606 const tokens = [];
17607 let currentLine = context.position.line;
17608 let currentCharacter = context.position.character;
17609 for (let i = 0; i < context.lines.length; i++) {
17610 const first = i === 0;
17611 const last = i === context.lines.length - 1;
17612 let line = context.lines[i];
17613 let index = 0;
17614 if (first && context.options.start) {
17615 const match = (_a = context.options.start) === null || _a === void 0 ? void 0 : _a.exec(line);
17616 if (match) {
17617 index = match.index + match[0].length;
17618 }
17619 }
17620 else {
17621 const match = (_b = context.options.line) === null || _b === void 0 ? void 0 : _b.exec(line);
17622 if (match) {
17623 index = match.index + match[0].length;
17624 }
17625 }
17626 if (last) {
17627 const match = (_c = context.options.end) === null || _c === void 0 ? void 0 : _c.exec(line);
17628 if (match) {
17629 line = line.substring(0, match.index);
17630 }
17631 }
17632 line = line.substring(0, lastCharacter(line));
17633 const whitespaceEnd = skipWhitespace(line, index);
17634 if (whitespaceEnd >= line.length) {
17635 // Only create a break token when we already have previous tokens
17636 if (tokens.length > 0) {
17637 const position = Position.create(currentLine, currentCharacter);
17638 tokens.push({
17639 type: 'break',
17640 content: '',
17641 range: Range.create(position, position)
17642 });
17643 }
17644 }
17645 else {
17646 tagRegex.lastIndex = index;
17647 const tagMatch = tagRegex.exec(line);
17648 if (tagMatch) {
17649 const fullMatch = tagMatch[0];
17650 const value = tagMatch[1];
17651 const start = Position.create(currentLine, currentCharacter + index);
17652 const end = Position.create(currentLine, currentCharacter + index + fullMatch.length);
17653 tokens.push({
17654 type: 'tag',
17655 content: value,
17656 range: Range.create(start, end)
17657 });
17658 index += fullMatch.length;
17659 index = skipWhitespace(line, index);
17660 }
17661 if (index < line.length) {
17662 const rest = line.substring(index);
17663 const inlineTagMatches = Array.from(rest.matchAll(inlineTagRegex));
17664 tokens.push(...buildInlineTokens(inlineTagMatches, rest, currentLine, currentCharacter + index));
17665 }
17666 }
17667 currentLine++;
17668 currentCharacter = 0;
17669 }
17670 // Remove last break token if there is one
17671 if (tokens.length > 0 && tokens[tokens.length - 1].type === 'break') {
17672 return tokens.slice(0, -1);
17673 }
17674 return tokens;
17675 }
17676 function buildInlineTokens(tags, line, lineIndex, characterIndex) {
17677 const tokens = [];
17678 if (tags.length === 0) {
17679 const start = Position.create(lineIndex, characterIndex);
17680 const end = Position.create(lineIndex, characterIndex + line.length);
17681 tokens.push({
17682 type: 'text',
17683 content: line,
17684 range: Range.create(start, end)
17685 });
17686 }
17687 else {
17688 let lastIndex = 0;
17689 for (const match of tags) {
17690 const matchIndex = match.index;
17691 const startContent = line.substring(lastIndex, matchIndex);
17692 if (startContent.length > 0) {
17693 tokens.push({
17694 type: 'text',
17695 content: line.substring(lastIndex, matchIndex),
17696 range: Range.create(Position.create(lineIndex, lastIndex + characterIndex), Position.create(lineIndex, matchIndex + characterIndex))
17697 });
17698 }
17699 let offset = startContent.length + 1;
17700 const tagName = match[1];
17701 tokens.push({
17702 type: 'inline-tag',
17703 content: tagName,
17704 range: Range.create(Position.create(lineIndex, lastIndex + offset + characterIndex), Position.create(lineIndex, lastIndex + offset + tagName.length + characterIndex))
17705 });
17706 offset += tagName.length;
17707 if (match.length === 4) {
17708 offset += match[2].length;
17709 const value = match[3];
17710 tokens.push({
17711 type: 'text',
17712 content: value,
17713 range: Range.create(Position.create(lineIndex, lastIndex + offset + characterIndex), Position.create(lineIndex, lastIndex + offset + value.length + characterIndex))
17714 });
17715 }
17716 else {
17717 tokens.push({
17718 type: 'text',
17719 content: '',
17720 range: Range.create(Position.create(lineIndex, lastIndex + offset + characterIndex), Position.create(lineIndex, lastIndex + offset + characterIndex))
17721 });
17722 }
17723 lastIndex = matchIndex + match[0].length;
17724 }
17725 const endContent = line.substring(lastIndex);
17726 if (endContent.length > 0) {
17727 tokens.push({
17728 type: 'text',
17729 content: endContent,
17730 range: Range.create(Position.create(lineIndex, lastIndex + characterIndex), Position.create(lineIndex, lastIndex + characterIndex + endContent.length))
17731 });
17732 }
17733 }
17734 return tokens;
17735 }
17736 const nonWhitespaceRegex = /\S/;
17737 const whitespaceEndRegex = /\s*$/;
17738 function skipWhitespace(line, index) {
17739 const match = line.substring(index).match(nonWhitespaceRegex);
17740 if (match) {
17741 return index + match.index;
17742 }
17743 else {
17744 return line.length;
17745 }
17746 }
17747 function lastCharacter(line) {
17748 const match = line.match(whitespaceEndRegex);
17749 if (match && typeof match.index === 'number') {
17750 return match.index;
17751 }
17752 return undefined;
17753 }
17754 // Parsing
17755 function parseJSDocComment(context) {
17756 var _a, _b, _c, _d;
17757 const startPosition = Position.create(context.position.line, context.position.character);
17758 if (context.tokens.length === 0) {
17759 return new JSDocCommentImpl([], Range.create(startPosition, startPosition));
17760 }
17761 const elements = [];
17762 while (context.index < context.tokens.length) {
17763 const element = parseJSDocElement(context, elements[elements.length - 1]);
17764 if (element) {
17765 elements.push(element);
17766 }
17767 }
17768 const start = (_b = (_a = elements[0]) === null || _a === void 0 ? void 0 : _a.range.start) !== null && _b !== void 0 ? _b : startPosition;
17769 const end = (_d = (_c = elements[elements.length - 1]) === null || _c === void 0 ? void 0 : _c.range.end) !== null && _d !== void 0 ? _d : startPosition;
17770 return new JSDocCommentImpl(elements, Range.create(start, end));
17771 }
17772 function parseJSDocElement(context, last) {
17773 const next = context.tokens[context.index];
17774 if (next.type === 'tag') {
17775 return parseJSDocTag(context, false);
17776 }
17777 else if (next.type === 'text' || next.type === 'inline-tag') {
17778 return parseJSDocText(context);
17779 }
17780 else {
17781 appendEmptyLine(next, last);
17782 context.index++;
17783 return undefined;
17784 }
17785 }
17786 function appendEmptyLine(token, element) {
17787 if (element) {
17788 const line = new JSDocLineImpl('', token.range);
17789 if ('inlines' in element) {
17790 element.inlines.push(line);
17791 }
17792 else {
17793 element.content.inlines.push(line);
17794 }
17795 }
17796 }
17797 function parseJSDocText(context) {
17798 let token = context.tokens[context.index];
17799 const firstToken = token;
17800 let lastToken = token;
17801 const lines = [];
17802 while (token && token.type !== 'break' && token.type !== 'tag') {
17803 lines.push(parseJSDocInline(context));
17804 lastToken = token;
17805 token = context.tokens[context.index];
17806 }
17807 return new JSDocTextImpl(lines, Range.create(firstToken.range.start, lastToken.range.end));
17808 }
17809 function parseJSDocInline(context) {
17810 const token = context.tokens[context.index];
17811 if (token.type === 'inline-tag') {
17812 return parseJSDocTag(context, true);
17813 }
17814 else {
17815 return parseJSDocLine(context);
17816 }
17817 }
17818 function parseJSDocTag(context, inline) {
17819 const tagToken = context.tokens[context.index++];
17820 const name = tagToken.content.substring(1);
17821 const nextToken = context.tokens[context.index];
17822 if ((nextToken === null || nextToken === void 0 ? void 0 : nextToken.type) === 'text') {
17823 if (inline) {
17824 const docLine = parseJSDocLine(context);
17825 return new JSDocTagImpl(name, new JSDocTextImpl([docLine], docLine.range), inline, Range.create(tagToken.range.start, docLine.range.end));
17826 }
17827 else {
17828 const textDoc = parseJSDocText(context);
17829 return new JSDocTagImpl(name, textDoc, inline, Range.create(tagToken.range.start, textDoc.range.end));
17830 }
17831 }
17832 else {
17833 const range = tagToken.range;
17834 return new JSDocTagImpl(name, new JSDocTextImpl([], range), inline, range);
17835 }
17836 }
17837 function parseJSDocLine(context) {
17838 const token = context.tokens[context.index++];
17839 return new JSDocLineImpl(token.content, token.range);
17840 }
17841 function normalizeOptions(options) {
17842 if (!options) {
17843 return normalizeOptions({
17844 start: '/**',
17845 end: '*/',
17846 line: '*'
17847 });
17848 }
17849 const { start, end, line } = options;
17850 return {
17851 start: normalizeOption(start, true),
17852 end: normalizeOption(end, false),
17853 line: normalizeOption(line, true)
17854 };
17855 }
17856 function normalizeOption(option, start) {
17857 if (typeof option === 'string' || typeof option === 'object') {
17858 const escaped = typeof option === 'string' ? (0,regexp_utils/* escapeRegExp */.hr)(option) : option.source;
17859 if (start) {
17860 return new RegExp(`^\\s*${escaped}`);
17861 }
17862 else {
17863 return new RegExp(`\\s*${escaped}\\s*$`);
17864 }
17865 }
17866 else {
17867 return option;
17868 }
17869 }
17870 class JSDocCommentImpl {
17871 constructor(elements, range) {
17872 this.elements = elements;
17873 this.range = range;
17874 }
17875 getTag(name) {
17876 return this.getAllTags().find(e => e.name === name);
17877 }
17878 getTags(name) {
17879 return this.getAllTags().filter(e => e.name === name);
17880 }
17881 getAllTags() {
17882 return this.elements.filter((e) => 'name' in e);
17883 }
17884 toString() {
17885 let value = '';
17886 for (const element of this.elements) {
17887 if (value.length === 0) {
17888 value = element.toString();
17889 }
17890 else {
17891 const text = element.toString();
17892 value += fillNewlines(value) + text;
17893 }
17894 }
17895 return value.trim();
17896 }
17897 toMarkdown(options) {
17898 let value = '';
17899 for (const element of this.elements) {
17900 if (value.length === 0) {
17901 value = element.toMarkdown(options);
17902 }
17903 else {
17904 const text = element.toMarkdown(options);
17905 value += fillNewlines(value) + text;
17906 }
17907 }
17908 return value.trim();
17909 }
17910 }
17911 class JSDocTagImpl {
17912 constructor(name, content, inline, range) {
17913 this.name = name;
17914 this.content = content;
17915 this.inline = inline;
17916 this.range = range;
17917 }
17918 toString() {
17919 let text = `@${this.name}`;
17920 const content = this.content.toString();
17921 if (this.content.inlines.length === 1) {
17922 text = `${text} ${content}`;
17923 }
17924 else if (this.content.inlines.length > 1) {
17925 text = `${text}\n${content}`;
17926 }
17927 if (this.inline) {
17928 // Inline tags are surrounded by curly braces
17929 return `{${text}}`;
17930 }
17931 else {
17932 return text;
17933 }
17934 }
17935 toMarkdown(options) {
17936 var _a, _b;
17937 return (_b = (_a = options === null || options === void 0 ? void 0 : options.renderTag) === null || _a === void 0 ? void 0 : _a.call(options, this)) !== null && _b !== void 0 ? _b : this.toMarkdownDefault(options);
17938 }
17939 toMarkdownDefault(options) {
17940 const content = this.content.toMarkdown(options);
17941 if (this.inline) {
17942 const rendered = renderInlineTag(this.name, content, options !== null && options !== void 0 ? options : {});
17943 if (typeof rendered === 'string') {
17944 return rendered;
17945 }
17946 }
17947 let marker = '';
17948 if ((options === null || options === void 0 ? void 0 : options.tag) === 'italic' || (options === null || options === void 0 ? void 0 : options.tag) === undefined) {
17949 marker = '*';
17950 }
17951 else if ((options === null || options === void 0 ? void 0 : options.tag) === 'bold') {
17952 marker = '**';
17953 }
17954 else if ((options === null || options === void 0 ? void 0 : options.tag) === 'bold-italic') {
17955 marker = '***';
17956 }
17957 let text = `${marker}@${this.name}${marker}`;
17958 if (this.content.inlines.length === 1) {
17959 text = `${text} — ${content}`;
17960 }
17961 else if (this.content.inlines.length > 1) {
17962 text = `${text}\n${content}`;
17963 }
17964 if (this.inline) {
17965 // Inline tags are surrounded by curly braces
17966 return `{${text}}`;
17967 }
17968 else {
17969 return text;
17970 }
17971 }
17972 }
17973 function renderInlineTag(tag, content, options) {
17974 var _a, _b;
17975 if (tag === 'linkplain' || tag === 'linkcode' || tag === 'link') {
17976 const index = content.indexOf(' ');
17977 let display = content;
17978 if (index > 0) {
17979 const displayStart = skipWhitespace(content, index);
17980 display = content.substring(displayStart);
17981 content = content.substring(0, index);
17982 }
17983 if (tag === 'linkcode' || (tag === 'link' && options.link === 'code')) {
17984 // Surround the display value in a markdown inline code block
17985 display = `\`${display}\``;
17986 }
17987 const renderedLink = (_b = (_a = options.renderLink) === null || _a === void 0 ? void 0 : _a.call(options, content, display)) !== null && _b !== void 0 ? _b : renderLinkDefault(content, display);
17988 return renderedLink;
17989 }
17990 return undefined;
17991 }
17992 function renderLinkDefault(content, display) {
17993 try {
17994 esm/* URI */.o.parse(content, true);
17995 return `[${display}](${content})`;
17996 }
17997 catch (_a) {
17998 return content;
17999 }
18000 }
18001 class JSDocTextImpl {
18002 constructor(lines, range) {
18003 this.inlines = lines;
18004 this.range = range;
18005 }
18006 toString() {
18007 let text = '';
18008 for (let i = 0; i < this.inlines.length; i++) {
18009 const inline = this.inlines[i];
18010 const next = this.inlines[i + 1];
18011 text += inline.toString();
18012 if (next && next.range.start.line > inline.range.start.line) {
18013 text += '\n';
18014 }
18015 }
18016 return text;
18017 }
18018 toMarkdown(options) {
18019 let text = '';
18020 for (let i = 0; i < this.inlines.length; i++) {
18021 const inline = this.inlines[i];
18022 const next = this.inlines[i + 1];
18023 text += inline.toMarkdown(options);
18024 if (next && next.range.start.line > inline.range.start.line) {
18025 text += '\n';
18026 }
18027 }
18028 return text;
18029 }
18030 }
18031 class JSDocLineImpl {
18032 constructor(text, range) {
18033 this.text = text;
18034 this.range = range;
18035 }
18036 toString() {
18037 return this.text;
18038 }
18039 toMarkdown() {
18040 return this.text;
18041 }
18042 }
18043 function fillNewlines(text) {
18044 if (text.endsWith('\n')) {
18045 return '\n';
18046 }
18047 else {
18048 return '\n\n';
18049 }
18050 }
18051 //# sourceMappingURL=jsdoc.js.map
18052 ;// CONCATENATED MODULE: ../node_modules/langium/lib/documentation/documentation-provider.js
18053 /******************************************************************************
18054 * Copyright 2023 TypeFox GmbH
18055 * This program and the accompanying materials are made available under the
18056 * terms of the MIT License, which is available in the project root.
18057 ******************************************************************************/
18058
18059
18060 class JSDocDocumentationProvider {
18061 constructor(services) {
18062 this.indexManager = services.shared.workspace.IndexManager;
18063 this.commentProvider = services.documentation.CommentProvider;
18064 }
18065 getDocumentation(node) {
18066 const comment = this.commentProvider.getComment(node);
18067 if (comment && isJSDoc(comment)) {
18068 const parsedJSDoc = parseJSDoc(comment);
18069 return parsedJSDoc.toMarkdown({
18070 renderLink: (link, display) => {
18071 return this.documentationLinkRenderer(node, link, display);
18072 },
18073 renderTag: (tag) => {
18074 return this.documentationTagRenderer(node, tag);
18075 }
18076 });
18077 }
18078 return undefined;
18079 }
18080 documentationLinkRenderer(node, name, display) {
18081 var _a;
18082 const description = (_a = this.findNameInPrecomputedScopes(node, name)) !== null && _a !== void 0 ? _a : this.findNameInGlobalScope(node, name);
18083 if (description && description.nameSegment) {
18084 const line = description.nameSegment.range.start.line + 1;
18085 const character = description.nameSegment.range.start.character + 1;
18086 const uri = description.documentUri.with({ fragment: `L${line},${character}` });
18087 return `[${display}](${uri.toString()})`;
18088 }
18089 else {
18090 return undefined;
18091 }
18092 }
18093 documentationTagRenderer(_node, _tag) {
18094 // Fall back to the default tag rendering
18095 return undefined;
18096 }
18097 findNameInPrecomputedScopes(node, name) {
18098 const document = (0,ast_utils/* getDocument */.Me)(node);
18099 const precomputed = document.precomputedScopes;
18100 if (!precomputed) {
18101 return undefined;
18102 }
18103 let currentNode = node;
18104 do {
18105 const allDescriptions = precomputed.get(currentNode);
18106 const description = allDescriptions.find(e => e.name === name);
18107 if (description) {
18108 return description;
18109 }
18110 currentNode = currentNode.$container;
18111 } while (currentNode);
18112 return undefined;
18113 }
18114 findNameInGlobalScope(node, name) {
18115 const description = this.indexManager.allElements().find(e => e.name === name);
18116 return description;
18117 }
18118 }
18119 //# sourceMappingURL=documentation-provider.js.map
18120 ;// CONCATENATED MODULE: ../node_modules/langium/lib/documentation/comment-provider.js
18121 /******************************************************************************
18122 * Copyright 2023 TypeFox GmbH
18123 * This program and the accompanying materials are made available under the
18124 * terms of the MIT License, which is available in the project root.
18125 ******************************************************************************/
18126
18127
18128 class DefaultCommentProvider {
18129 constructor(services) {
18130 this.grammarConfig = () => services.parser.GrammarConfig;
18131 }
18132 getComment(node) {
18133 var _a;
18134 if (isAstNodeWithComment(node)) {
18135 return node.$comment;
18136 }
18137 return (_a = (0,cst_utils/* findCommentNode */.LK)(node.$cstNode, this.grammarConfig().multilineCommentRules)) === null || _a === void 0 ? void 0 : _a.text;
18138 }
18139 }
18140 //# sourceMappingURL=comment-provider.js.map
18141 ;// CONCATENATED MODULE: ../node_modules/langium/lib/parser/async-parser.js
18142 /******************************************************************************
18143 * Copyright 2023 TypeFox GmbH
18144 * This program and the accompanying materials are made available under the
18145 * terms of the MIT License, which is available in the project root.
18146 ******************************************************************************/
18147
18148
18149 /**
18150 * Default implementation of the async parser which simply wraps the sync parser in a promise.
18151 *
18152 * @remarks
18153 * A real implementation would create worker threads or web workers to offload the parsing work.
18154 */
18155 class DefaultAsyncParser {
18156 constructor(services) {
18157 this.syncParser = services.parser.LangiumParser;
18158 }
18159 parse(text, _cancelToken) {
18160 return Promise.resolve(this.syncParser.parse(text));
18161 }
18162 }
18163 class AbstractThreadedAsyncParser {
18164 constructor(services) {
18165 /**
18166 * The thread count determines how many threads are used to parse files in parallel.
18167 * The default value is 8. Decreasing this value increases startup performance, but decreases parallel parsing performance.
18168 */
18169 this.threadCount = 8;
18170 /**
18171 * The termination delay determines how long the parser waits for a thread to finish after a cancellation request.
18172 * The default value is 200(ms).
18173 */
18174 this.terminationDelay = 200;
18175 this.workerPool = [];
18176 this.queue = [];
18177 this.hydrator = services.serializer.Hydrator;
18178 }
18179 initializeWorkers() {
18180 while (this.workerPool.length < this.threadCount) {
18181 const worker = this.createWorker();
18182 worker.onReady(() => {
18183 if (this.queue.length > 0) {
18184 const deferred = this.queue.shift();
18185 if (deferred) {
18186 worker.lock();
18187 deferred.resolve(worker);
18188 }
18189 }
18190 });
18191 this.workerPool.push(worker);
18192 }
18193 }
18194 async parse(text, cancelToken) {
18195 const worker = await this.acquireParserWorker(cancelToken);
18196 const deferred = new Deferred();
18197 let timeout;
18198 // If the cancellation token is requested, we wait for a certain time before terminating the worker.
18199 // Since the cancellation token lives longer than the parsing process, we need to dispose the event listener.
18200 // Otherwise, we might accidentally terminate the worker after the parsing process has finished.
18201 const cancellation = cancelToken.onCancellationRequested(() => {
18202 timeout = setTimeout(() => {
18203 this.terminateWorker(worker);
18204 }, this.terminationDelay);
18205 });
18206 worker.parse(text).then(result => {
18207 const hydrated = this.hydrator.hydrate(result);
18208 deferred.resolve(hydrated);
18209 }).catch(err => {
18210 deferred.reject(err);
18211 }).finally(() => {
18212 cancellation.dispose();
18213 clearTimeout(timeout);
18214 });
18215 return deferred.promise;
18216 }
18217 terminateWorker(worker) {
18218 worker.terminate();
18219 const index = this.workerPool.indexOf(worker);
18220 if (index >= 0) {
18221 this.workerPool.splice(index, 1);
18222 }
18223 }
18224 async acquireParserWorker(cancelToken) {
18225 this.initializeWorkers();
18226 for (const worker of this.workerPool) {
18227 if (worker.ready) {
18228 worker.lock();
18229 return worker;
18230 }
18231 }
18232 const deferred = new Deferred();
18233 cancelToken.onCancellationRequested(() => {
18234 const index = this.queue.indexOf(deferred);
18235 if (index >= 0) {
18236 this.queue.splice(index, 1);
18237 }
18238 deferred.reject(OperationCancelled);
18239 });
18240 this.queue.push(deferred);
18241 return deferred.promise;
18242 }
18243 }
18244 class ParserWorker {
18245 get ready() {
18246 return this._ready;
18247 }
18248 get onReady() {
18249 return this.onReadyEmitter.event;
18250 }
18251 constructor(sendMessage, onMessage, onError, terminate) {
18252 this.onReadyEmitter = new Emitter();
18253 this.deferred = new Deferred();
18254 this._ready = true;
18255 this._parsing = false;
18256 this.sendMessage = sendMessage;
18257 this._terminate = terminate;
18258 onMessage(result => {
18259 const parseResult = result;
18260 this.deferred.resolve(parseResult);
18261 this.unlock();
18262 });
18263 onError(error => {
18264 this.deferred.reject(error);
18265 this.unlock();
18266 });
18267 }
18268 terminate() {
18269 this.deferred.reject(OperationCancelled);
18270 this._terminate();
18271 }
18272 lock() {
18273 this._ready = false;
18274 }
18275 unlock() {
18276 this._parsing = false;
18277 this._ready = true;
18278 this.onReadyEmitter.fire();
18279 }
18280 parse(text) {
18281 if (this._parsing) {
18282 throw new Error('Parser worker is busy');
18283 }
18284 this._parsing = true;
18285 this.deferred = new Deferred();
18286 this.sendMessage(text);
18287 return this.deferred.promise;
18288 }
18289 }
18290 //# sourceMappingURL=async-parser.js.map
18291 ;// CONCATENATED MODULE: ../node_modules/langium/lib/workspace/workspace-lock.js
18292 /******************************************************************************
18293 * Copyright 2023 TypeFox GmbH
18294 * This program and the accompanying materials are made available under the
18295 * terms of the MIT License, which is available in the project root.
18296 ******************************************************************************/
18297
18298
18299 class DefaultWorkspaceLock {
18300 constructor() {
18301 this.previousTokenSource = new cancellation.CancellationTokenSource();
18302 this.writeQueue = [];
18303 this.readQueue = [];
18304 this.done = true;
18305 }
18306 write(action) {
18307 this.cancelWrite();
18308 const tokenSource = startCancelableOperation();
18309 this.previousTokenSource = tokenSource;
18310 return this.enqueue(this.writeQueue, action, tokenSource.token);
18311 }
18312 read(action) {
18313 return this.enqueue(this.readQueue, action);
18314 }
18315 enqueue(queue, action, cancellationToken = cancellation.CancellationToken.None) {
18316 const deferred = new promise_utils_Deferred();
18317 const entry = {
18318 action,
18319 deferred,
18320 cancellationToken
18321 };
18322 queue.push(entry);
18323 this.performNextOperation();
18324 return deferred.promise;
18325 }
18326 async performNextOperation() {
18327 if (!this.done) {
18328 return;
18329 }
18330 const entries = [];
18331 if (this.writeQueue.length > 0) {
18332 // Just perform the next write action
18333 entries.push(this.writeQueue.shift());
18334 }
18335 else if (this.readQueue.length > 0) {
18336 // Empty the read queue and perform all actions in parallel
18337 entries.push(...this.readQueue.splice(0, this.readQueue.length));
18338 }
18339 else {
18340 return;
18341 }
18342 this.done = false;
18343 await Promise.all(entries.map(async ({ action, deferred, cancellationToken }) => {
18344 try {
18345 // Move the execution of the action to the next event loop tick via `Promise.resolve()`
18346 const result = await Promise.resolve().then(() => action(cancellationToken));
18347 deferred.resolve(result);
18348 }
18349 catch (err) {
18350 if (isOperationCancelled(err)) {
18351 // If the operation was cancelled, we don't want to reject the promise
18352 deferred.resolve(undefined);
18353 }
18354 else {
18355 deferred.reject(err);
18356 }
18357 }
18358 }));
18359 this.done = true;
18360 this.performNextOperation();
18361 }
18362 cancelWrite() {
18363 this.previousTokenSource.cancel();
18364 }
18365 }
18366 //# sourceMappingURL=workspace-lock.js.map
18367 ;// CONCATENATED MODULE: ../node_modules/langium/lib/serializer/hydrator.js
18368 /******************************************************************************
18369 * Copyright 2024 TypeFox GmbH
18370 * This program and the accompanying materials are made available under the
18371 * terms of the MIT License, which is available in the project root.
18372 ******************************************************************************/
18373
18374
18375
18376
18377
18378
18379 class DefaultHydrator {
18380 constructor(services) {
18381 this.grammarElementIdMap = new BiMap();
18382 this.tokenTypeIdMap = new BiMap();
18383 this.grammar = services.Grammar;
18384 this.lexer = services.parser.Lexer;
18385 this.linker = services.references.Linker;
18386 }
18387 dehydrate(result) {
18388 return {
18389 lexerErrors: result.lexerErrors,
18390 lexerReport: result.lexerReport ? this.dehydrateLexerReport(result.lexerReport) : undefined,
18391 // We need to create shallow copies of the errors
18392 // The original errors inherit from the `Error` class, which is not transferable across worker threads
18393 parserErrors: result.parserErrors.map(e => (Object.assign(Object.assign({}, e), { message: e.message }))),
18394 value: this.dehydrateAstNode(result.value, this.createDehyrationContext(result.value))
18395 };
18396 }
18397 dehydrateLexerReport(lexerReport) {
18398 // By default, lexer reports are serializable
18399 return lexerReport;
18400 }
18401 createDehyrationContext(node) {
18402 const astNodes = new Map();
18403 const cstNodes = new Map();
18404 for (const astNode of (0,ast_utils/* streamAst */.Zc)(node)) {
18405 astNodes.set(astNode, {});
18406 }
18407 if (node.$cstNode) {
18408 for (const cstNode of (0,cst_utils/* streamCst */._t)(node.$cstNode)) {
18409 cstNodes.set(cstNode, {});
18410 }
18411 }
18412 return {
18413 astNodes,
18414 cstNodes
18415 };
18416 }
18417 dehydrateAstNode(node, context) {
18418 const obj = context.astNodes.get(node);
18419 obj.$type = node.$type;
18420 obj.$containerIndex = node.$containerIndex;
18421 obj.$containerProperty = node.$containerProperty;
18422 if (node.$cstNode !== undefined) {
18423 obj.$cstNode = this.dehydrateCstNode(node.$cstNode, context);
18424 }
18425 for (const [name, value] of Object.entries(node)) {
18426 if (name.startsWith('$')) {
18427 continue;
18428 }
18429 if (Array.isArray(value)) {
18430 const arr = [];
18431 obj[name] = arr;
18432 for (const item of value) {
18433 if ((0,syntax_tree/* isAstNode */.xA)(item)) {
18434 arr.push(this.dehydrateAstNode(item, context));
18435 }
18436 else if ((0,syntax_tree/* isReference */.Yk)(item)) {
18437 arr.push(this.dehydrateReference(item, context));
18438 }
18439 else {
18440 arr.push(item);
18441 }
18442 }
18443 }
18444 else if ((0,syntax_tree/* isAstNode */.xA)(value)) {
18445 obj[name] = this.dehydrateAstNode(value, context);
18446 }
18447 else if ((0,syntax_tree/* isReference */.Yk)(value)) {
18448 obj[name] = this.dehydrateReference(value, context);
18449 }
18450 else if (value !== undefined) {
18451 obj[name] = value;
18452 }
18453 }
18454 return obj;
18455 }
18456 dehydrateReference(reference, context) {
18457 const obj = {};
18458 obj.$refText = reference.$refText;
18459 if (reference.$refNode) {
18460 obj.$refNode = context.cstNodes.get(reference.$refNode);
18461 }
18462 return obj;
18463 }
18464 dehydrateCstNode(node, context) {
18465 const cstNode = context.cstNodes.get(node);
18466 if ((0,syntax_tree/* isRootCstNode */.U8)(node)) {
18467 cstNode.fullText = node.fullText;
18468 }
18469 else {
18470 // Note: This returns undefined for hidden nodes (i.e. comments)
18471 cstNode.grammarSource = this.getGrammarElementId(node.grammarSource);
18472 }
18473 cstNode.hidden = node.hidden;
18474 cstNode.astNode = context.astNodes.get(node.astNode);
18475 if ((0,syntax_tree/* isCompositeCstNode */.al)(node)) {
18476 cstNode.content = node.content.map(child => this.dehydrateCstNode(child, context));
18477 }
18478 else if ((0,syntax_tree/* isLeafCstNode */.dm)(node)) {
18479 cstNode.tokenType = node.tokenType.name;
18480 cstNode.offset = node.offset;
18481 cstNode.length = node.length;
18482 cstNode.startLine = node.range.start.line;
18483 cstNode.startColumn = node.range.start.character;
18484 cstNode.endLine = node.range.end.line;
18485 cstNode.endColumn = node.range.end.character;
18486 }
18487 return cstNode;
18488 }
18489 hydrate(result) {
18490 const node = result.value;
18491 const context = this.createHydrationContext(node);
18492 if ('$cstNode' in node) {
18493 this.hydrateCstNode(node.$cstNode, context);
18494 }
18495 return {
18496 lexerErrors: result.lexerErrors,
18497 lexerReport: result.lexerReport,
18498 parserErrors: result.parserErrors,
18499 value: this.hydrateAstNode(node, context)
18500 };
18501 }
18502 createHydrationContext(node) {
18503 const astNodes = new Map();
18504 const cstNodes = new Map();
18505 for (const astNode of (0,ast_utils/* streamAst */.Zc)(node)) {
18506 astNodes.set(astNode, {});
18507 }
18508 let root;
18509 if (node.$cstNode) {
18510 for (const cstNode of (0,cst_utils/* streamCst */._t)(node.$cstNode)) {
18511 let cst;
18512 if ('fullText' in cstNode) {
18513 cst = new RootCstNodeImpl(cstNode.fullText);
18514 root = cst;
18515 }
18516 else if ('content' in cstNode) {
18517 cst = new CompositeCstNodeImpl();
18518 }
18519 else if ('tokenType' in cstNode) {
18520 cst = this.hydrateCstLeafNode(cstNode);
18521 }
18522 if (cst) {
18523 cstNodes.set(cstNode, cst);
18524 cst.root = root;
18525 }
18526 }
18527 }
18528 return {
18529 astNodes,
18530 cstNodes
18531 };
18532 }
18533 hydrateAstNode(node, context) {
18534 const astNode = context.astNodes.get(node);
18535 astNode.$type = node.$type;
18536 astNode.$containerIndex = node.$containerIndex;
18537 astNode.$containerProperty = node.$containerProperty;
18538 if (node.$cstNode) {
18539 astNode.$cstNode = context.cstNodes.get(node.$cstNode);
18540 }
18541 for (const [name, value] of Object.entries(node)) {
18542 if (name.startsWith('$')) {
18543 continue;
18544 }
18545 if (Array.isArray(value)) {
18546 const arr = [];
18547 astNode[name] = arr;
18548 for (const item of value) {
18549 if ((0,syntax_tree/* isAstNode */.xA)(item)) {
18550 arr.push(this.setParent(this.hydrateAstNode(item, context), astNode));
18551 }
18552 else if ((0,syntax_tree/* isReference */.Yk)(item)) {
18553 arr.push(this.hydrateReference(item, astNode, name, context));
18554 }
18555 else {
18556 arr.push(item);
18557 }
18558 }
18559 }
18560 else if ((0,syntax_tree/* isAstNode */.xA)(value)) {
18561 astNode[name] = this.setParent(this.hydrateAstNode(value, context), astNode);
18562 }
18563 else if ((0,syntax_tree/* isReference */.Yk)(value)) {
18564 astNode[name] = this.hydrateReference(value, astNode, name, context);
18565 }
18566 else if (value !== undefined) {
18567 astNode[name] = value;
18568 }
18569 }
18570 return astNode;
18571 }
18572 setParent(node, parent) {
18573 node.$container = parent;
18574 return node;
18575 }
18576 hydrateReference(reference, node, name, context) {
18577 return this.linker.buildReference(node, name, context.cstNodes.get(reference.$refNode), reference.$refText);
18578 }
18579 hydrateCstNode(cstNode, context, num = 0) {
18580 const cstNodeObj = context.cstNodes.get(cstNode);
18581 if (typeof cstNode.grammarSource === 'number') {
18582 cstNodeObj.grammarSource = this.getGrammarElement(cstNode.grammarSource);
18583 }
18584 cstNodeObj.astNode = context.astNodes.get(cstNode.astNode);
18585 if ((0,syntax_tree/* isCompositeCstNode */.al)(cstNodeObj)) {
18586 for (const child of cstNode.content) {
18587 const hydrated = this.hydrateCstNode(child, context, num++);
18588 cstNodeObj.content.push(hydrated);
18589 }
18590 }
18591 return cstNodeObj;
18592 }
18593 hydrateCstLeafNode(cstNode) {
18594 const tokenType = this.getTokenType(cstNode.tokenType);
18595 const offset = cstNode.offset;
18596 const length = cstNode.length;
18597 const startLine = cstNode.startLine;
18598 const startColumn = cstNode.startColumn;
18599 const endLine = cstNode.endLine;
18600 const endColumn = cstNode.endColumn;
18601 const hidden = cstNode.hidden;
18602 const node = new LeafCstNodeImpl(offset, length, {
18603 start: {
18604 line: startLine,
18605 character: startColumn
18606 },
18607 end: {
18608 line: endLine,
18609 character: endColumn
18610 }
18611 }, tokenType, hidden);
18612 return node;
18613 }
18614 getTokenType(name) {
18615 return this.lexer.definition[name];
18616 }
18617 getGrammarElementId(node) {
18618 if (!node) {
18619 return undefined;
18620 }
18621 if (this.grammarElementIdMap.size === 0) {
18622 this.createGrammarElementIdMap();
18623 }
18624 return this.grammarElementIdMap.get(node);
18625 }
18626 getGrammarElement(id) {
18627 if (this.grammarElementIdMap.size === 0) {
18628 this.createGrammarElementIdMap();
18629 }
18630 const element = this.grammarElementIdMap.getKey(id);
18631 return element;
18632 }
18633 createGrammarElementIdMap() {
18634 let id = 0;
18635 for (const element of (0,ast_utils/* streamAst */.Zc)(this.grammar)) {
18636 if ((0,ast/* isAbstractElement */.zJ)(element)) {
18637 this.grammarElementIdMap.set(element, id++);
18638 }
18639 }
18640 }
18641 }
18642 //# sourceMappingURL=hydrator.js.map
18643 ;// CONCATENATED MODULE: ../node_modules/langium/lib/default-module.js
18644 /******************************************************************************
18645 * Copyright 2021 TypeFox GmbH
18646 * This program and the accompanying materials are made available under the
18647 * terms of the MIT License, which is available in the project root.
18648 ******************************************************************************/
18649
18650
18651
18652
18653
18654
18655
18656
18657
18658
18659
18660
18661
18662
18663
18664
18665
18666
18667
18668
18669
18670
18671
18672
18673
18674
18675
18676
18677 /**
18678 * Creates a dependency injection module configuring the default core services.
18679 * This is a set of services that are dedicated to a specific language.
18680 */
18681 function createDefaultCoreModule(context) {
18682 return {
18683 documentation: {
18684 CommentProvider: (services) => new DefaultCommentProvider(services),
18685 DocumentationProvider: (services) => new JSDocDocumentationProvider(services)
18686 },
18687 parser: {
18688 AsyncParser: (services) => new DefaultAsyncParser(services),
18689 GrammarConfig: (services) => createGrammarConfig(services),
18690 LangiumParser: (services) => createLangiumParser(services),
18691 CompletionParser: (services) => createCompletionParser(services),
18692 ValueConverter: () => new value_converter/* DefaultValueConverter */.t(),
18693 TokenBuilder: () => new token_builder/* DefaultTokenBuilder */.P(),
18694 Lexer: (services) => new DefaultLexer(services),
18695 ParserErrorMessageProvider: () => new LangiumParserErrorMessageProvider(),
18696 LexerErrorMessageProvider: () => new DefaultLexerErrorMessageProvider()
18697 },
18698 workspace: {
18699 AstNodeLocator: () => new DefaultAstNodeLocator(),
18700 AstNodeDescriptionProvider: (services) => new DefaultAstNodeDescriptionProvider(services),
18701 ReferenceDescriptionProvider: (services) => new DefaultReferenceDescriptionProvider(services)
18702 },
18703 references: {
18704 Linker: (services) => new DefaultLinker(services),
18705 NameProvider: () => new DefaultNameProvider(),
18706 ScopeProvider: (services) => new DefaultScopeProvider(services),
18707 ScopeComputation: (services) => new DefaultScopeComputation(services),
18708 References: (services) => new DefaultReferences(services)
18709 },
18710 serializer: {
18711 Hydrator: (services) => new DefaultHydrator(services),
18712 JsonSerializer: (services) => new DefaultJsonSerializer(services)
18713 },
18714 validation: {
18715 DocumentValidator: (services) => new DefaultDocumentValidator(services),
18716 ValidationRegistry: (services) => new ValidationRegistry(services)
18717 },
18718 shared: () => context.shared
18719 };
18720 }
18721 /**
18722 * Creates a dependency injection module configuring the default shared core services.
18723 * This is the set of services that are shared between multiple languages.
18724 */
18725 function createDefaultSharedCoreModule(context) {
18726 return {
18727 ServiceRegistry: (services) => new DefaultServiceRegistry(services),
18728 workspace: {
18729 LangiumDocuments: (services) => new DefaultLangiumDocuments(services),
18730 LangiumDocumentFactory: (services) => new DefaultLangiumDocumentFactory(services),
18731 DocumentBuilder: (services) => new DefaultDocumentBuilder(services),
18732 IndexManager: (services) => new DefaultIndexManager(services),
18733 WorkspaceManager: (services) => new DefaultWorkspaceManager(services),
18734 FileSystemProvider: (services) => context.fileSystemProvider(services),
18735 WorkspaceLock: () => new DefaultWorkspaceLock(),
18736 ConfigurationProvider: (services) => new DefaultConfigurationProvider(services)
18737 }
18738 };
18739 }
18740 //# sourceMappingURL=default-module.js.map
18741
18742 /***/ }),
18743
18744 /***/ 81210:
18745 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
18746
18747 "use strict";
18748 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
18749 /* harmony export */ f3: () => (/* binding */ inject)
18750 /* harmony export */ });
18751 /* unused harmony exports Module, eagerLoad */
18752 /******************************************************************************
18753 * Copyright 2021 TypeFox GmbH
18754 * This program and the accompanying materials are made available under the
18755 * terms of the MIT License, which is available in the project root.
18756 ******************************************************************************/
18757 var Module;
18758 (function (Module) {
18759 Module.merge = (m1, m2) => _merge(_merge({}, m1), m2);
18760 })(Module || (Module = {}));
18761 /**
18762 * Given a set of modules, the inject function returns a lazily evaluated injector
18763 * that injects dependencies into the requested service when it is requested the
18764 * first time. Subsequent requests will return the same service.
18765 *
18766 * In the case of cyclic dependencies, an Error will be thrown. This can be fixed
18767 * by injecting a provider `() => T` instead of a `T`.
18768 *
18769 * Please note that the arguments may be objects or arrays. However, the result will
18770 * be an object. Using it with for..of will have no effect.
18771 *
18772 * @param module1 first Module
18773 * @param module2 (optional) second Module
18774 * @param module3 (optional) third Module
18775 * @param module4 (optional) fourth Module
18776 * @param module5 (optional) fifth Module
18777 * @param module6 (optional) sixth Module
18778 * @param module7 (optional) seventh Module
18779 * @param module8 (optional) eighth Module
18780 * @param module9 (optional) ninth Module
18781 * @returns a new object of type I
18782 */
18783 function inject(module1, module2, module3, module4, module5, module6, module7, module8, module9) {
18784 const module = [module1, module2, module3, module4, module5, module6, module7, module8, module9].reduce(_merge, {});
18785 return _inject(module);
18786 }
18787 const isProxy = Symbol('isProxy');
18788 /**
18789 * Eagerly load all services in the given dependency injection container. This is sometimes
18790 * necessary because services can register event listeners in their constructors.
18791 */
18792 function eagerLoad(item) {
18793 if (item && item[isProxy]) {
18794 for (const value of Object.values(item)) {
18795 eagerLoad(value);
18796 }
18797 }
18798 return item;
18799 }
18800 /**
18801 * Helper function that returns an injector by creating a proxy.
18802 * Invariant: injector is of type I. If injector is undefined, then T = I.
18803 */
18804 function _inject(module, injector) {
18805 const proxy = new Proxy({}, {
18806 deleteProperty: () => false,
18807 set: () => {
18808 throw new Error('Cannot set property on injected service container');
18809 },
18810 get: (obj, prop) => {
18811 if (prop === isProxy) {
18812 return true;
18813 }
18814 else {
18815 return _resolve(obj, prop, module, injector || proxy);
18816 }
18817 },
18818 getOwnPropertyDescriptor: (obj, prop) => (_resolve(obj, prop, module, injector || proxy), Object.getOwnPropertyDescriptor(obj, prop)), // used by for..in
18819 has: (_, prop) => prop in module, // used by ..in..
18820 ownKeys: () => [...Object.getOwnPropertyNames(module)] // used by for..in
18821 });
18822 return proxy;
18823 }
18824 /**
18825 * Internally used to tag a requested dependency, directly before calling the factory.
18826 * This allows us to find cycles during instance creation.
18827 */
18828 const __requested__ = Symbol();
18829 /**
18830 * Returns the value `obj[prop]`. If the value does not exist, yet, it is resolved from
18831 * the module description. The result of service factories is cached. Groups are
18832 * recursively proxied.
18833 *
18834 * @param obj an object holding all group proxies and services
18835 * @param prop the key of a value within obj
18836 * @param module an object containing groups and service factories
18837 * @param injector the first level proxy that provides access to all values
18838 * @returns the requested value `obj[prop]`
18839 * @throws Error if a dependency cycle is detected
18840 */
18841 function _resolve(obj, prop, module, injector) {
18842 if (prop in obj) {
18843 if (obj[prop] instanceof Error) {
18844 throw new Error('Construction failure. Please make sure that your dependencies are constructable.', { cause: obj[prop] });
18845 }
18846 if (obj[prop] === __requested__) {
18847 throw new Error('Cycle detected. Please make "' + String(prop) + '" lazy. Visit https://langium.org/docs/reference/configuration-services/#resolving-cyclic-dependencies');
18848 }
18849 return obj[prop];
18850 }
18851 else if (prop in module) {
18852 const value = module[prop];
18853 obj[prop] = __requested__;
18854 try {
18855 obj[prop] = (typeof value === 'function') ? value(injector) : _inject(value, injector);
18856 }
18857 catch (error) {
18858 obj[prop] = error instanceof Error ? error : undefined;
18859 throw error;
18860 }
18861 return obj[prop];
18862 }
18863 else {
18864 return undefined;
18865 }
18866 }
18867 /**
18868 * Performs a deep-merge of two modules by writing source entries into the target module.
18869 *
18870 * @param target the module which is written
18871 * @param source the module which is read
18872 * @returns the target module
18873 */
18874 function _merge(target, source) {
18875 if (source) {
18876 for (const [key, value2] of Object.entries(source)) {
18877 if (value2 !== undefined) {
18878 const value1 = target[key];
18879 if (value1 !== null && value2 !== null && typeof value1 === 'object' && typeof value2 === 'object') {
18880 target[key] = _merge(value1, value2);
18881 }
18882 else {
18883 target[key] = value2;
18884 }
18885 }
18886 }
18887 }
18888 return target;
18889 }
18890 //# sourceMappingURL=dependency-injection.js.map
18891
18892 /***/ }),
18893
18894 /***/ 34905:
18895 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
18896
18897 "use strict";
18898 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
18899 /* harmony export */ B7: () => (/* binding */ isAssignment),
18900 /* harmony export */ Bf: () => (/* binding */ isCharacterRange),
18901 /* harmony export */ Bi: () => (/* binding */ isNegatedToken),
18902 /* harmony export */ F8: () => (/* binding */ isDisjunction),
18903 /* harmony export */ F9: () => (/* binding */ isParserRule),
18904 /* harmony export */ Ii: () => (/* binding */ isNegation),
18905 /* harmony export */ Iy: () => (/* binding */ isSimpleType),
18906 /* harmony export */ Ki: () => (/* binding */ isCrossReference),
18907 /* harmony export */ L: () => (/* binding */ isBooleanLiteral),
18908 /* harmony export */ LG: () => (/* binding */ isAction),
18909 /* harmony export */ MS: () => (/* binding */ isTerminalRule),
18910 /* harmony export */ MZ: () => (/* binding */ isAlternatives),
18911 /* harmony export */ Mp: () => (/* binding */ isReturnType),
18912 /* harmony export */ OG: () => (/* binding */ isUntilToken),
18913 /* harmony export */ P9: () => (/* binding */ isType),
18914 /* harmony export */ QV: () => (/* binding */ isInterface),
18915 /* harmony export */ SV: () => (/* binding */ LangiumGrammarAstReflection),
18916 /* harmony export */ S_: () => (/* binding */ isInferredType),
18917 /* harmony export */ Sg: () => (/* binding */ isRegexToken),
18918 /* harmony export */ TB: () => (/* binding */ isConjunction),
18919 /* harmony export */ V7: () => (/* binding */ isTerminalAlternatives),
18920 /* harmony export */ W1: () => (/* binding */ isUnorderedGroup),
18921 /* harmony export */ X9: () => (/* binding */ isTerminalGroup),
18922 /* harmony export */ gf: () => (/* binding */ isTerminalRuleCall),
18923 /* harmony export */ p1: () => (/* binding */ isKeyword),
18924 /* harmony export */ qm: () => (/* binding */ isWildcard),
18925 /* harmony export */ rT: () => (/* binding */ isEndOfFile),
18926 /* harmony export */ t3: () => (/* binding */ isRuleCall),
18927 /* harmony export */ ty: () => (/* binding */ isGroup),
18928 /* harmony export */ yW: () => (/* binding */ isParameterReference),
18929 /* harmony export */ zJ: () => (/* binding */ isAbstractElement)
18930 /* harmony export */ });
18931 /* unused harmony exports LangiumGrammarTerminals, AbstractRule, isAbstractRule, AbstractType, isAbstractType, Condition, isCondition, isFeatureName, isPrimitiveType, TypeDefinition, isTypeDefinition, ValueLiteral, isValueLiteral, AbstractElement, ArrayLiteral, isArrayLiteral, ArrayType, isArrayType, BooleanLiteral, Conjunction, Disjunction, Grammar, isGrammar, GrammarImport, isGrammarImport, InferredType, Interface, NamedArgument, isNamedArgument, Negation, NumberLiteral, isNumberLiteral, Parameter, isParameter, ParameterReference, ParserRule, ReferenceType, isReferenceType, ReturnType, SimpleType, StringLiteral, isStringLiteral, TerminalRule, Type, TypeAttribute, isTypeAttribute, UnionType, isUnionType, Action, Alternatives, Assignment, CharacterRange, CrossReference, EndOfFile, Group, Keyword, NegatedToken, RegexToken, RuleCall, TerminalAlternatives, TerminalGroup, TerminalRuleCall, UnorderedGroup, UntilToken, Wildcard, reflection */
18932 /* harmony import */ var _syntax_tree_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(91303);
18933 /******************************************************************************
18934 * This file was generated by langium-cli 3.3.0.
18935 * DO NOT EDIT MANUALLY!
18936 ******************************************************************************/
18937
18938 const LangiumGrammarTerminals = {
18939 ID: /\^?[_a-zA-Z][\w_]*/,
18940 STRING: /"(\\.|[^"\\])*"|'(\\.|[^'\\])*'/,
18941 NUMBER: /NaN|-?((\d*\.\d+|\d+)([Ee][+-]?\d+)?|Infinity)/,
18942 RegexLiteral: /\/(?![*+?])(?:[^\r\n\[/\\]|\\.|\[(?:[^\r\n\]\\]|\\.)*\])+\/[a-z]*/,
18943 WS: /\s+/,
18944 ML_COMMENT: /\/\*[\s\S]*?\*\//,
18945 SL_COMMENT: /\/\/[^\n\r]*/,
18946 };
18947 const AbstractRule = 'AbstractRule';
18948 function isAbstractRule(item) {
18949 return reflection.isInstance(item, AbstractRule);
18950 }
18951 const AbstractType = 'AbstractType';
18952 function isAbstractType(item) {
18953 return reflection.isInstance(item, AbstractType);
18954 }
18955 const Condition = 'Condition';
18956 function isCondition(item) {
18957 return reflection.isInstance(item, Condition);
18958 }
18959 function isFeatureName(item) {
18960 return isPrimitiveType(item) || item === 'current' || item === 'entry' || item === 'extends' || item === 'false' || item === 'fragment' || item === 'grammar' || item === 'hidden' || item === 'import' || item === 'interface' || item === 'returns' || item === 'terminal' || item === 'true' || item === 'type' || item === 'infer' || item === 'infers' || item === 'with' || (typeof item === 'string' && (/\^?[_a-zA-Z][\w_]*/.test(item)));
18961 }
18962 function isPrimitiveType(item) {
18963 return item === 'string' || item === 'number' || item === 'boolean' || item === 'Date' || item === 'bigint';
18964 }
18965 const TypeDefinition = 'TypeDefinition';
18966 function isTypeDefinition(item) {
18967 return reflection.isInstance(item, TypeDefinition);
18968 }
18969 const ValueLiteral = 'ValueLiteral';
18970 function isValueLiteral(item) {
18971 return reflection.isInstance(item, ValueLiteral);
18972 }
18973 const AbstractElement = 'AbstractElement';
18974 function isAbstractElement(item) {
18975 return reflection.isInstance(item, AbstractElement);
18976 }
18977 const ArrayLiteral = 'ArrayLiteral';
18978 function isArrayLiteral(item) {
18979 return reflection.isInstance(item, ArrayLiteral);
18980 }
18981 const ArrayType = 'ArrayType';
18982 function isArrayType(item) {
18983 return reflection.isInstance(item, ArrayType);
18984 }
18985 const BooleanLiteral = 'BooleanLiteral';
18986 function isBooleanLiteral(item) {
18987 return reflection.isInstance(item, BooleanLiteral);
18988 }
18989 const Conjunction = 'Conjunction';
18990 function isConjunction(item) {
18991 return reflection.isInstance(item, Conjunction);
18992 }
18993 const Disjunction = 'Disjunction';
18994 function isDisjunction(item) {
18995 return reflection.isInstance(item, Disjunction);
18996 }
18997 const Grammar = 'Grammar';
18998 function isGrammar(item) {
18999 return reflection.isInstance(item, Grammar);
19000 }
19001 const GrammarImport = 'GrammarImport';
19002 function isGrammarImport(item) {
19003 return reflection.isInstance(item, GrammarImport);
19004 }
19005 const InferredType = 'InferredType';
19006 function isInferredType(item) {
19007 return reflection.isInstance(item, InferredType);
19008 }
19009 const Interface = 'Interface';
19010 function isInterface(item) {
19011 return reflection.isInstance(item, Interface);
19012 }
19013 const NamedArgument = 'NamedArgument';
19014 function isNamedArgument(item) {
19015 return reflection.isInstance(item, NamedArgument);
19016 }
19017 const Negation = 'Negation';
19018 function isNegation(item) {
19019 return reflection.isInstance(item, Negation);
19020 }
19021 const NumberLiteral = 'NumberLiteral';
19022 function isNumberLiteral(item) {
19023 return reflection.isInstance(item, NumberLiteral);
19024 }
19025 const Parameter = 'Parameter';
19026 function isParameter(item) {
19027 return reflection.isInstance(item, Parameter);
19028 }
19029 const ParameterReference = 'ParameterReference';
19030 function isParameterReference(item) {
19031 return reflection.isInstance(item, ParameterReference);
19032 }
19033 const ParserRule = 'ParserRule';
19034 function isParserRule(item) {
19035 return reflection.isInstance(item, ParserRule);
19036 }
19037 const ReferenceType = 'ReferenceType';
19038 function isReferenceType(item) {
19039 return reflection.isInstance(item, ReferenceType);
19040 }
19041 const ReturnType = 'ReturnType';
19042 function isReturnType(item) {
19043 return reflection.isInstance(item, ReturnType);
19044 }
19045 const SimpleType = 'SimpleType';
19046 function isSimpleType(item) {
19047 return reflection.isInstance(item, SimpleType);
19048 }
19049 const StringLiteral = 'StringLiteral';
19050 function isStringLiteral(item) {
19051 return reflection.isInstance(item, StringLiteral);
19052 }
19053 const TerminalRule = 'TerminalRule';
19054 function isTerminalRule(item) {
19055 return reflection.isInstance(item, TerminalRule);
19056 }
19057 const Type = 'Type';
19058 function isType(item) {
19059 return reflection.isInstance(item, Type);
19060 }
19061 const TypeAttribute = 'TypeAttribute';
19062 function isTypeAttribute(item) {
19063 return reflection.isInstance(item, TypeAttribute);
19064 }
19065 const UnionType = 'UnionType';
19066 function isUnionType(item) {
19067 return reflection.isInstance(item, UnionType);
19068 }
19069 const Action = 'Action';
19070 function isAction(item) {
19071 return reflection.isInstance(item, Action);
19072 }
19073 const Alternatives = 'Alternatives';
19074 function isAlternatives(item) {
19075 return reflection.isInstance(item, Alternatives);
19076 }
19077 const Assignment = 'Assignment';
19078 function isAssignment(item) {
19079 return reflection.isInstance(item, Assignment);
19080 }
19081 const CharacterRange = 'CharacterRange';
19082 function isCharacterRange(item) {
19083 return reflection.isInstance(item, CharacterRange);
19084 }
19085 const CrossReference = 'CrossReference';
19086 function isCrossReference(item) {
19087 return reflection.isInstance(item, CrossReference);
19088 }
19089 const EndOfFile = 'EndOfFile';
19090 function isEndOfFile(item) {
19091 return reflection.isInstance(item, EndOfFile);
19092 }
19093 const Group = 'Group';
19094 function isGroup(item) {
19095 return reflection.isInstance(item, Group);
19096 }
19097 const Keyword = 'Keyword';
19098 function isKeyword(item) {
19099 return reflection.isInstance(item, Keyword);
19100 }
19101 const NegatedToken = 'NegatedToken';
19102 function isNegatedToken(item) {
19103 return reflection.isInstance(item, NegatedToken);
19104 }
19105 const RegexToken = 'RegexToken';
19106 function isRegexToken(item) {
19107 return reflection.isInstance(item, RegexToken);
19108 }
19109 const RuleCall = 'RuleCall';
19110 function isRuleCall(item) {
19111 return reflection.isInstance(item, RuleCall);
19112 }
19113 const TerminalAlternatives = 'TerminalAlternatives';
19114 function isTerminalAlternatives(item) {
19115 return reflection.isInstance(item, TerminalAlternatives);
19116 }
19117 const TerminalGroup = 'TerminalGroup';
19118 function isTerminalGroup(item) {
19119 return reflection.isInstance(item, TerminalGroup);
19120 }
19121 const TerminalRuleCall = 'TerminalRuleCall';
19122 function isTerminalRuleCall(item) {
19123 return reflection.isInstance(item, TerminalRuleCall);
19124 }
19125 const UnorderedGroup = 'UnorderedGroup';
19126 function isUnorderedGroup(item) {
19127 return reflection.isInstance(item, UnorderedGroup);
19128 }
19129 const UntilToken = 'UntilToken';
19130 function isUntilToken(item) {
19131 return reflection.isInstance(item, UntilToken);
19132 }
19133 const Wildcard = 'Wildcard';
19134 function isWildcard(item) {
19135 return reflection.isInstance(item, Wildcard);
19136 }
19137 class LangiumGrammarAstReflection extends _syntax_tree_js__WEBPACK_IMPORTED_MODULE_0__/* .AbstractAstReflection */ .$v {
19138 getAllTypes() {
19139 return [AbstractElement, AbstractRule, AbstractType, Action, Alternatives, ArrayLiteral, ArrayType, Assignment, BooleanLiteral, CharacterRange, Condition, Conjunction, CrossReference, Disjunction, EndOfFile, Grammar, GrammarImport, Group, InferredType, Interface, Keyword, NamedArgument, NegatedToken, Negation, NumberLiteral, Parameter, ParameterReference, ParserRule, ReferenceType, RegexToken, ReturnType, RuleCall, SimpleType, StringLiteral, TerminalAlternatives, TerminalGroup, TerminalRule, TerminalRuleCall, Type, TypeAttribute, TypeDefinition, UnionType, UnorderedGroup, UntilToken, ValueLiteral, Wildcard];
19140 }
19141 computeIsSubtype(subtype, supertype) {
19142 switch (subtype) {
19143 case Action:
19144 case Alternatives:
19145 case Assignment:
19146 case CharacterRange:
19147 case CrossReference:
19148 case EndOfFile:
19149 case Group:
19150 case Keyword:
19151 case NegatedToken:
19152 case RegexToken:
19153 case RuleCall:
19154 case TerminalAlternatives:
19155 case TerminalGroup:
19156 case TerminalRuleCall:
19157 case UnorderedGroup:
19158 case UntilToken:
19159 case Wildcard: {
19160 return this.isSubtype(AbstractElement, supertype);
19161 }
19162 case ArrayLiteral:
19163 case NumberLiteral:
19164 case StringLiteral: {
19165 return this.isSubtype(ValueLiteral, supertype);
19166 }
19167 case ArrayType:
19168 case ReferenceType:
19169 case SimpleType:
19170 case UnionType: {
19171 return this.isSubtype(TypeDefinition, supertype);
19172 }
19173 case BooleanLiteral: {
19174 return this.isSubtype(Condition, supertype) || this.isSubtype(ValueLiteral, supertype);
19175 }
19176 case Conjunction:
19177 case Disjunction:
19178 case Negation:
19179 case ParameterReference: {
19180 return this.isSubtype(Condition, supertype);
19181 }
19182 case InferredType:
19183 case Interface:
19184 case Type: {
19185 return this.isSubtype(AbstractType, supertype);
19186 }
19187 case ParserRule: {
19188 return this.isSubtype(AbstractRule, supertype) || this.isSubtype(AbstractType, supertype);
19189 }
19190 case TerminalRule: {
19191 return this.isSubtype(AbstractRule, supertype);
19192 }
19193 default: {
19194 return false;
19195 }
19196 }
19197 }
19198 getReferenceType(refInfo) {
19199 const referenceId = `${refInfo.container.$type}:${refInfo.property}`;
19200 switch (referenceId) {
19201 case 'Action:type':
19202 case 'CrossReference:type':
19203 case 'Interface:superTypes':
19204 case 'ParserRule:returnType':
19205 case 'SimpleType:typeRef': {
19206 return AbstractType;
19207 }
19208 case 'Grammar:hiddenTokens':
19209 case 'ParserRule:hiddenTokens':
19210 case 'RuleCall:rule': {
19211 return AbstractRule;
19212 }
19213 case 'Grammar:usedGrammars': {
19214 return Grammar;
19215 }
19216 case 'NamedArgument:parameter':
19217 case 'ParameterReference:parameter': {
19218 return Parameter;
19219 }
19220 case 'TerminalRuleCall:rule': {
19221 return TerminalRule;
19222 }
19223 default: {
19224 throw new Error(`${referenceId} is not a valid reference id.`);
19225 }
19226 }
19227 }
19228 getTypeMetaData(type) {
19229 switch (type) {
19230 case AbstractElement: {
19231 return {
19232 name: AbstractElement,
19233 properties: [
19234 { name: 'cardinality' },
19235 { name: 'lookahead' }
19236 ]
19237 };
19238 }
19239 case ArrayLiteral: {
19240 return {
19241 name: ArrayLiteral,
19242 properties: [
19243 { name: 'elements', defaultValue: [] }
19244 ]
19245 };
19246 }
19247 case ArrayType: {
19248 return {
19249 name: ArrayType,
19250 properties: [
19251 { name: 'elementType' }
19252 ]
19253 };
19254 }
19255 case BooleanLiteral: {
19256 return {
19257 name: BooleanLiteral,
19258 properties: [
19259 { name: 'true', defaultValue: false }
19260 ]
19261 };
19262 }
19263 case Conjunction: {
19264 return {
19265 name: Conjunction,
19266 properties: [
19267 { name: 'left' },
19268 { name: 'right' }
19269 ]
19270 };
19271 }
19272 case Disjunction: {
19273 return {
19274 name: Disjunction,
19275 properties: [
19276 { name: 'left' },
19277 { name: 'right' }
19278 ]
19279 };
19280 }
19281 case Grammar: {
19282 return {
19283 name: Grammar,
19284 properties: [
19285 { name: 'definesHiddenTokens', defaultValue: false },
19286 { name: 'hiddenTokens', defaultValue: [] },
19287 { name: 'imports', defaultValue: [] },
19288 { name: 'interfaces', defaultValue: [] },
19289 { name: 'isDeclared', defaultValue: false },
19290 { name: 'name' },
19291 { name: 'rules', defaultValue: [] },
19292 { name: 'types', defaultValue: [] },
19293 { name: 'usedGrammars', defaultValue: [] }
19294 ]
19295 };
19296 }
19297 case GrammarImport: {
19298 return {
19299 name: GrammarImport,
19300 properties: [
19301 { name: 'path' }
19302 ]
19303 };
19304 }
19305 case InferredType: {
19306 return {
19307 name: InferredType,
19308 properties: [
19309 { name: 'name' }
19310 ]
19311 };
19312 }
19313 case Interface: {
19314 return {
19315 name: Interface,
19316 properties: [
19317 { name: 'attributes', defaultValue: [] },
19318 { name: 'name' },
19319 { name: 'superTypes', defaultValue: [] }
19320 ]
19321 };
19322 }
19323 case NamedArgument: {
19324 return {
19325 name: NamedArgument,
19326 properties: [
19327 { name: 'calledByName', defaultValue: false },
19328 { name: 'parameter' },
19329 { name: 'value' }
19330 ]
19331 };
19332 }
19333 case Negation: {
19334 return {
19335 name: Negation,
19336 properties: [
19337 { name: 'value' }
19338 ]
19339 };
19340 }
19341 case NumberLiteral: {
19342 return {
19343 name: NumberLiteral,
19344 properties: [
19345 { name: 'value' }
19346 ]
19347 };
19348 }
19349 case Parameter: {
19350 return {
19351 name: Parameter,
19352 properties: [
19353 { name: 'name' }
19354 ]
19355 };
19356 }
19357 case ParameterReference: {
19358 return {
19359 name: ParameterReference,
19360 properties: [
19361 { name: 'parameter' }
19362 ]
19363 };
19364 }
19365 case ParserRule: {
19366 return {
19367 name: ParserRule,
19368 properties: [
19369 { name: 'dataType' },
19370 { name: 'definesHiddenTokens', defaultValue: false },
19371 { name: 'definition' },
19372 { name: 'entry', defaultValue: false },
19373 { name: 'fragment', defaultValue: false },
19374 { name: 'hiddenTokens', defaultValue: [] },
19375 { name: 'inferredType' },
19376 { name: 'name' },
19377 { name: 'parameters', defaultValue: [] },
19378 { name: 'returnType' },
19379 { name: 'wildcard', defaultValue: false }
19380 ]
19381 };
19382 }
19383 case ReferenceType: {
19384 return {
19385 name: ReferenceType,
19386 properties: [
19387 { name: 'referenceType' }
19388 ]
19389 };
19390 }
19391 case ReturnType: {
19392 return {
19393 name: ReturnType,
19394 properties: [
19395 { name: 'name' }
19396 ]
19397 };
19398 }
19399 case SimpleType: {
19400 return {
19401 name: SimpleType,
19402 properties: [
19403 { name: 'primitiveType' },
19404 { name: 'stringType' },
19405 { name: 'typeRef' }
19406 ]
19407 };
19408 }
19409 case StringLiteral: {
19410 return {
19411 name: StringLiteral,
19412 properties: [
19413 { name: 'value' }
19414 ]
19415 };
19416 }
19417 case TerminalRule: {
19418 return {
19419 name: TerminalRule,
19420 properties: [
19421 { name: 'definition' },
19422 { name: 'fragment', defaultValue: false },
19423 { name: 'hidden', defaultValue: false },
19424 { name: 'name' },
19425 { name: 'type' }
19426 ]
19427 };
19428 }
19429 case Type: {
19430 return {
19431 name: Type,
19432 properties: [
19433 { name: 'name' },
19434 { name: 'type' }
19435 ]
19436 };
19437 }
19438 case TypeAttribute: {
19439 return {
19440 name: TypeAttribute,
19441 properties: [
19442 { name: 'defaultValue' },
19443 { name: 'isOptional', defaultValue: false },
19444 { name: 'name' },
19445 { name: 'type' }
19446 ]
19447 };
19448 }
19449 case UnionType: {
19450 return {
19451 name: UnionType,
19452 properties: [
19453 { name: 'types', defaultValue: [] }
19454 ]
19455 };
19456 }
19457 case Action: {
19458 return {
19459 name: Action,
19460 properties: [
19461 { name: 'cardinality' },
19462 { name: 'feature' },
19463 { name: 'inferredType' },
19464 { name: 'lookahead' },
19465 { name: 'operator' },
19466 { name: 'type' }
19467 ]
19468 };
19469 }
19470 case Alternatives: {
19471 return {
19472 name: Alternatives,
19473 properties: [
19474 { name: 'cardinality' },
19475 { name: 'elements', defaultValue: [] },
19476 { name: 'lookahead' }
19477 ]
19478 };
19479 }
19480 case Assignment: {
19481 return {
19482 name: Assignment,
19483 properties: [
19484 { name: 'cardinality' },
19485 { name: 'feature' },
19486 { name: 'lookahead' },
19487 { name: 'operator' },
19488 { name: 'terminal' }
19489 ]
19490 };
19491 }
19492 case CharacterRange: {
19493 return {
19494 name: CharacterRange,
19495 properties: [
19496 { name: 'cardinality' },
19497 { name: 'left' },
19498 { name: 'lookahead' },
19499 { name: 'right' }
19500 ]
19501 };
19502 }
19503 case CrossReference: {
19504 return {
19505 name: CrossReference,
19506 properties: [
19507 { name: 'cardinality' },
19508 { name: 'deprecatedSyntax', defaultValue: false },
19509 { name: 'lookahead' },
19510 { name: 'terminal' },
19511 { name: 'type' }
19512 ]
19513 };
19514 }
19515 case EndOfFile: {
19516 return {
19517 name: EndOfFile,
19518 properties: [
19519 { name: 'cardinality' },
19520 { name: 'lookahead' }
19521 ]
19522 };
19523 }
19524 case Group: {
19525 return {
19526 name: Group,
19527 properties: [
19528 { name: 'cardinality' },
19529 { name: 'elements', defaultValue: [] },
19530 { name: 'guardCondition' },
19531 { name: 'lookahead' }
19532 ]
19533 };
19534 }
19535 case Keyword: {
19536 return {
19537 name: Keyword,
19538 properties: [
19539 { name: 'cardinality' },
19540 { name: 'lookahead' },
19541 { name: 'value' }
19542 ]
19543 };
19544 }
19545 case NegatedToken: {
19546 return {
19547 name: NegatedToken,
19548 properties: [
19549 { name: 'cardinality' },
19550 { name: 'lookahead' },
19551 { name: 'terminal' }
19552 ]
19553 };
19554 }
19555 case RegexToken: {
19556 return {
19557 name: RegexToken,
19558 properties: [
19559 { name: 'cardinality' },
19560 { name: 'lookahead' },
19561 { name: 'regex' }
19562 ]
19563 };
19564 }
19565 case RuleCall: {
19566 return {
19567 name: RuleCall,
19568 properties: [
19569 { name: 'arguments', defaultValue: [] },
19570 { name: 'cardinality' },
19571 { name: 'lookahead' },
19572 { name: 'rule' }
19573 ]
19574 };
19575 }
19576 case TerminalAlternatives: {
19577 return {
19578 name: TerminalAlternatives,
19579 properties: [
19580 { name: 'cardinality' },
19581 { name: 'elements', defaultValue: [] },
19582 { name: 'lookahead' }
19583 ]
19584 };
19585 }
19586 case TerminalGroup: {
19587 return {
19588 name: TerminalGroup,
19589 properties: [
19590 { name: 'cardinality' },
19591 { name: 'elements', defaultValue: [] },
19592 { name: 'lookahead' }
19593 ]
19594 };
19595 }
19596 case TerminalRuleCall: {
19597 return {
19598 name: TerminalRuleCall,
19599 properties: [
19600 { name: 'cardinality' },
19601 { name: 'lookahead' },
19602 { name: 'rule' }
19603 ]
19604 };
19605 }
19606 case UnorderedGroup: {
19607 return {
19608 name: UnorderedGroup,
19609 properties: [
19610 { name: 'cardinality' },
19611 { name: 'elements', defaultValue: [] },
19612 { name: 'lookahead' }
19613 ]
19614 };
19615 }
19616 case UntilToken: {
19617 return {
19618 name: UntilToken,
19619 properties: [
19620 { name: 'cardinality' },
19621 { name: 'lookahead' },
19622 { name: 'terminal' }
19623 ]
19624 };
19625 }
19626 case Wildcard: {
19627 return {
19628 name: Wildcard,
19629 properties: [
19630 { name: 'cardinality' },
19631 { name: 'lookahead' }
19632 ]
19633 };
19634 }
19635 default: {
19636 return {
19637 name: type,
19638 properties: []
19639 };
19640 }
19641 }
19642 }
19643 }
19644 const reflection = new LangiumGrammarAstReflection();
19645 //# sourceMappingURL=ast.js.map
19646
19647 /***/ }),
19648
19649 /***/ 35481:
19650 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
19651
19652 "use strict";
19653 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
19654 /* harmony export */ P: () => (/* binding */ DefaultTokenBuilder)
19655 /* harmony export */ });
19656 /* harmony import */ var chevrotain__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(34326);
19657 /* harmony import */ var _languages_generated_ast_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(34905);
19658 /* harmony import */ var _utils_ast_utils_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(74857);
19659 /* harmony import */ var _utils_grammar_utils_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(30447);
19660 /* harmony import */ var _utils_regexp_utils_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(43078);
19661 /* harmony import */ var _utils_stream_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(99293);
19662 /******************************************************************************
19663 * Copyright 2021 TypeFox GmbH
19664 * This program and the accompanying materials are made available under the
19665 * terms of the MIT License, which is available in the project root.
19666 ******************************************************************************/
19667
19668
19669
19670
19671
19672
19673 class DefaultTokenBuilder {
19674 constructor() {
19675 /**
19676 * The list of diagnostics stored during the lexing process of a single text.
19677 */
19678 this.diagnostics = [];
19679 }
19680 buildTokens(grammar, options) {
19681 const reachableRules = (0,_utils_stream_js__WEBPACK_IMPORTED_MODULE_1__/* .stream */ .Vw)((0,_utils_grammar_utils_js__WEBPACK_IMPORTED_MODULE_2__/* .getAllReachableRules */ .VD)(grammar, false));
19682 const terminalTokens = this.buildTerminalTokens(reachableRules);
19683 const tokens = this.buildKeywordTokens(reachableRules, terminalTokens, options);
19684 terminalTokens.forEach(terminalToken => {
19685 const pattern = terminalToken.PATTERN;
19686 if (typeof pattern === 'object' && pattern && 'test' in pattern && (0,_utils_regexp_utils_js__WEBPACK_IMPORTED_MODULE_3__/* .isWhitespace */ .cb)(pattern)) {
19687 tokens.unshift(terminalToken);
19688 }
19689 else {
19690 tokens.push(terminalToken);
19691 }
19692 });
19693 // We don't need to add the EOF token explicitly.
19694 // It is automatically available at the end of the token stream.
19695 return tokens;
19696 }
19697 // eslint-disable-next-line @typescript-eslint/no-unused-vars
19698 flushLexingReport(text) {
19699 return { diagnostics: this.popDiagnostics() };
19700 }
19701 popDiagnostics() {
19702 const diagnostics = [...this.diagnostics];
19703 this.diagnostics = [];
19704 return diagnostics;
19705 }
19706 buildTerminalTokens(rules) {
19707 return rules.filter(_languages_generated_ast_js__WEBPACK_IMPORTED_MODULE_4__/* .isTerminalRule */ .MS).filter(e => !e.fragment)
19708 .map(terminal => this.buildTerminalToken(terminal)).toArray();
19709 }
19710 buildTerminalToken(terminal) {
19711 const regex = (0,_utils_grammar_utils_js__WEBPACK_IMPORTED_MODULE_2__/* .terminalRegex */ .s1)(terminal);
19712 const pattern = this.requiresCustomPattern(regex) ? this.regexPatternFunction(regex) : regex;
19713 const tokenType = {
19714 name: terminal.name,
19715 PATTERN: pattern,
19716 };
19717 if (typeof pattern === 'function') {
19718 tokenType.LINE_BREAKS = true;
19719 }
19720 if (terminal.hidden) {
19721 // Only skip tokens that are able to accept whitespace
19722 tokenType.GROUP = (0,_utils_regexp_utils_js__WEBPACK_IMPORTED_MODULE_3__/* .isWhitespace */ .cb)(regex) ? chevrotain__WEBPACK_IMPORTED_MODULE_0__/* .Lexer */ .hW.SKIPPED : 'hidden';
19723 }
19724 return tokenType;
19725 }
19726 requiresCustomPattern(regex) {
19727 if (regex.flags.includes('u') || regex.flags.includes('s')) {
19728 // Unicode and dotall regexes are not supported by Chevrotain.
19729 return true;
19730 }
19731 else if (regex.source.includes('?<=') || regex.source.includes('?<!')) {
19732 // Negative and positive lookbehind are not supported by Chevrotain yet.
19733 return true;
19734 }
19735 else {
19736 return false;
19737 }
19738 }
19739 regexPatternFunction(regex) {
19740 const stickyRegex = new RegExp(regex, regex.flags + 'y');
19741 return (text, offset) => {
19742 stickyRegex.lastIndex = offset;
19743 const execResult = stickyRegex.exec(text);
19744 return execResult;
19745 };
19746 }
19747 buildKeywordTokens(rules, terminalTokens, options) {
19748 return rules
19749 // We filter by parser rules, since keywords in terminal rules get transformed into regex and are not actual tokens
19750 .filter(_languages_generated_ast_js__WEBPACK_IMPORTED_MODULE_4__/* .isParserRule */ .F9)
19751 .flatMap(rule => (0,_utils_ast_utils_js__WEBPACK_IMPORTED_MODULE_5__/* .streamAllContents */ .VY)(rule).filter(_languages_generated_ast_js__WEBPACK_IMPORTED_MODULE_4__/* .isKeyword */ .p1))
19752 .distinct(e => e.value).toArray()
19753 // Sort keywords by descending length
19754 .sort((a, b) => b.value.length - a.value.length)
19755 .map(keyword => this.buildKeywordToken(keyword, terminalTokens, Boolean(options === null || options === void 0 ? void 0 : options.caseInsensitive)));
19756 }
19757 buildKeywordToken(keyword, terminalTokens, caseInsensitive) {
19758 const keywordPattern = this.buildKeywordPattern(keyword, caseInsensitive);
19759 const tokenType = {
19760 name: keyword.value,
19761 PATTERN: keywordPattern,
19762 LONGER_ALT: this.findLongerAlt(keyword, terminalTokens)
19763 };
19764 if (typeof keywordPattern === 'function') {
19765 tokenType.LINE_BREAKS = true;
19766 }
19767 return tokenType;
19768 }
19769 buildKeywordPattern(keyword, caseInsensitive) {
19770 return caseInsensitive ?
19771 new RegExp((0,_utils_regexp_utils_js__WEBPACK_IMPORTED_MODULE_3__/* .getCaseInsensitivePattern */ .cp)(keyword.value)) :
19772 keyword.value;
19773 }
19774 findLongerAlt(keyword, terminalTokens) {
19775 return terminalTokens.reduce((longerAlts, token) => {
19776 const pattern = token === null || token === void 0 ? void 0 : token.PATTERN;
19777 if ((pattern === null || pattern === void 0 ? void 0 : pattern.source) && (0,_utils_regexp_utils_js__WEBPACK_IMPORTED_MODULE_3__/* .partialMatches */ .XC)('^' + pattern.source + '$', keyword.value)) {
19778 longerAlts.push(token);
19779 }
19780 return longerAlts;
19781 }, []);
19782 }
19783 }
19784 //# sourceMappingURL=token-builder.js.map
19785
19786 /***/ }),
19787
19788 /***/ 46174:
19789 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
19790
19791 "use strict";
19792 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
19793 /* harmony export */ t: () => (/* binding */ DefaultValueConverter)
19794 /* harmony export */ });
19795 /* unused harmony export ValueConverter */
19796 /* harmony import */ var _languages_generated_ast_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(34905);
19797 /* harmony import */ var _utils_grammar_utils_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(30447);
19798 /******************************************************************************
19799 * Copyright 2021 TypeFox GmbH
19800 * This program and the accompanying materials are made available under the
19801 * terms of the MIT License, which is available in the project root.
19802 ******************************************************************************/
19803
19804
19805 class DefaultValueConverter {
19806 convert(input, cstNode) {
19807 let feature = cstNode.grammarSource;
19808 if ((0,_languages_generated_ast_js__WEBPACK_IMPORTED_MODULE_0__/* .isCrossReference */ .Ki)(feature)) {
19809 feature = (0,_utils_grammar_utils_js__WEBPACK_IMPORTED_MODULE_1__/* .getCrossReferenceTerminal */ .eN)(feature);
19810 }
19811 if ((0,_languages_generated_ast_js__WEBPACK_IMPORTED_MODULE_0__/* .isRuleCall */ .t3)(feature)) {
19812 const rule = feature.rule.ref;
19813 if (!rule) {
19814 throw new Error('This cst node was not parsed by a rule.');
19815 }
19816 return this.runConverter(rule, input, cstNode);
19817 }
19818 return input;
19819 }
19820 // eslint-disable-next-line @typescript-eslint/no-unused-vars
19821 runConverter(rule, input, cstNode) {
19822 var _a;
19823 switch (rule.name.toUpperCase()) {
19824 case 'INT': return ValueConverter.convertInt(input);
19825 case 'STRING': return ValueConverter.convertString(input);
19826 case 'ID': return ValueConverter.convertID(input);
19827 }
19828 switch ((_a = (0,_utils_grammar_utils_js__WEBPACK_IMPORTED_MODULE_1__/* .getRuleType */ .mJ)(rule)) === null || _a === void 0 ? void 0 : _a.toLowerCase()) {
19829 case 'number': return ValueConverter.convertNumber(input);
19830 case 'boolean': return ValueConverter.convertBoolean(input);
19831 case 'bigint': return ValueConverter.convertBigint(input);
19832 case 'date': return ValueConverter.convertDate(input);
19833 default: return input;
19834 }
19835 }
19836 }
19837 var ValueConverter;
19838 (function (ValueConverter) {
19839 function convertString(input) {
19840 let result = '';
19841 for (let i = 1; i < input.length - 1; i++) {
19842 const c = input.charAt(i);
19843 if (c === '\\') {
19844 const c1 = input.charAt(++i);
19845 result += convertEscapeCharacter(c1);
19846 }
19847 else {
19848 result += c;
19849 }
19850 }
19851 return result;
19852 }
19853 ValueConverter.convertString = convertString;
19854 function convertEscapeCharacter(char) {
19855 switch (char) {
19856 case 'b': return '\b';
19857 case 'f': return '\f';
19858 case 'n': return '\n';
19859 case 'r': return '\r';
19860 case 't': return '\t';
19861 case 'v': return '\v';
19862 case '0': return '\0';
19863 default: return char;
19864 }
19865 }
19866 function convertID(input) {
19867 if (input.charAt(0) === '^') {
19868 return input.substring(1);
19869 }
19870 else {
19871 return input;
19872 }
19873 }
19874 ValueConverter.convertID = convertID;
19875 function convertInt(input) {
19876 return parseInt(input);
19877 }
19878 ValueConverter.convertInt = convertInt;
19879 function convertBigint(input) {
19880 return BigInt(input);
19881 }
19882 ValueConverter.convertBigint = convertBigint;
19883 function convertDate(input) {
19884 return new Date(input);
19885 }
19886 ValueConverter.convertDate = convertDate;
19887 function convertNumber(input) {
19888 return Number(input);
19889 }
19890 ValueConverter.convertNumber = convertNumber;
19891 function convertBoolean(input) {
19892 return input.toLowerCase() === 'true';
19893 }
19894 ValueConverter.convertBoolean = convertBoolean;
19895 })(ValueConverter || (ValueConverter = {}));
19896 //# sourceMappingURL=value-converter.js.map
19897
19898 /***/ }),
19899
19900 /***/ 91303:
19901 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
19902
19903 "use strict";
19904 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
19905 /* harmony export */ $v: () => (/* binding */ AbstractAstReflection),
19906 /* harmony export */ SI: () => (/* binding */ isAstNodeDescription),
19907 /* harmony export */ U8: () => (/* binding */ isRootCstNode),
19908 /* harmony export */ Yk: () => (/* binding */ isReference),
19909 /* harmony export */ al: () => (/* binding */ isCompositeCstNode),
19910 /* harmony export */ dm: () => (/* binding */ isLeafCstNode),
19911 /* harmony export */ et: () => (/* binding */ isLinkingError),
19912 /* harmony export */ xA: () => (/* binding */ isAstNode)
19913 /* harmony export */ });
19914 /******************************************************************************
19915 * Copyright 2021 TypeFox GmbH
19916 * This program and the accompanying materials are made available under the
19917 * terms of the MIT License, which is available in the project root.
19918 ******************************************************************************/
19919 function isAstNode(obj) {
19920 return typeof obj === 'object' && obj !== null && typeof obj.$type === 'string';
19921 }
19922 function isReference(obj) {
19923 return typeof obj === 'object' && obj !== null && typeof obj.$refText === 'string';
19924 }
19925 function isAstNodeDescription(obj) {
19926 return typeof obj === 'object' && obj !== null
19927 && typeof obj.name === 'string'
19928 && typeof obj.type === 'string'
19929 && typeof obj.path === 'string';
19930 }
19931 function isLinkingError(obj) {
19932 return typeof obj === 'object' && obj !== null
19933 && isAstNode(obj.container)
19934 && isReference(obj.reference)
19935 && typeof obj.message === 'string';
19936 }
19937 /**
19938 * An abstract implementation of the {@link AstReflection} interface.
19939 * Serves to cache subtype computation results to improve performance throughout different parts of Langium.
19940 */
19941 class AbstractAstReflection {
19942 constructor() {
19943 this.subtypes = {};
19944 this.allSubtypes = {};
19945 }
19946 isInstance(node, type) {
19947 return isAstNode(node) && this.isSubtype(node.$type, type);
19948 }
19949 isSubtype(subtype, supertype) {
19950 if (subtype === supertype) {
19951 return true;
19952 }
19953 let nested = this.subtypes[subtype];
19954 if (!nested) {
19955 nested = this.subtypes[subtype] = {};
19956 }
19957 const existing = nested[supertype];
19958 if (existing !== undefined) {
19959 return existing;
19960 }
19961 else {
19962 const result = this.computeIsSubtype(subtype, supertype);
19963 nested[supertype] = result;
19964 return result;
19965 }
19966 }
19967 getAllSubTypes(type) {
19968 const existing = this.allSubtypes[type];
19969 if (existing) {
19970 return existing;
19971 }
19972 else {
19973 const allTypes = this.getAllTypes();
19974 const types = [];
19975 for (const possibleSubType of allTypes) {
19976 if (this.isSubtype(possibleSubType, type)) {
19977 types.push(possibleSubType);
19978 }
19979 }
19980 this.allSubtypes[type] = types;
19981 return types;
19982 }
19983 }
19984 }
19985 function isCompositeCstNode(node) {
19986 return typeof node === 'object' && node !== null && Array.isArray(node.content);
19987 }
19988 function isLeafCstNode(node) {
19989 return typeof node === 'object' && node !== null && typeof node.tokenType === 'object';
19990 }
19991 function isRootCstNode(node) {
19992 return isCompositeCstNode(node) && typeof node.fullText === 'string';
19993 }
19994 //# sourceMappingURL=syntax-tree.js.map
19995
19996 /***/ }),
19997
19998 /***/ 74857:
19999 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
20000
20001 "use strict";
20002 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
20003 /* harmony export */ E$: () => (/* binding */ findRootNode),
20004 /* harmony export */ Me: () => (/* binding */ getDocument),
20005 /* harmony export */ VY: () => (/* binding */ streamAllContents),
20006 /* harmony export */ V_: () => (/* binding */ getContainerOfType),
20007 /* harmony export */ Zc: () => (/* binding */ streamAst),
20008 /* harmony export */ a1: () => (/* binding */ assignMandatoryProperties),
20009 /* harmony export */ b2: () => (/* binding */ linkContentToContainer),
20010 /* harmony export */ fy: () => (/* binding */ streamReferences),
20011 /* harmony export */ sx: () => (/* binding */ streamContents)
20012 /* harmony export */ });
20013 /* unused harmony exports hasContainerOfType, findLocalReferences, copyAstNode */
20014 /* harmony import */ var _syntax_tree_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(91303);
20015 /* harmony import */ var _stream_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(99293);
20016 /* harmony import */ var _cst_utils_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(13871);
20017 /******************************************************************************
20018 * Copyright 2021 TypeFox GmbH
20019 * This program and the accompanying materials are made available under the
20020 * terms of the MIT License, which is available in the project root.
20021 ******************************************************************************/
20022
20023
20024
20025 /**
20026 * Link the `$container` and other related properties of every AST node that is directly contained
20027 * in the given `node`.
20028 */
20029 function linkContentToContainer(node) {
20030 for (const [name, value] of Object.entries(node)) {
20031 if (!name.startsWith('$')) {
20032 if (Array.isArray(value)) {
20033 value.forEach((item, index) => {
20034 if ((0,_syntax_tree_js__WEBPACK_IMPORTED_MODULE_0__/* .isAstNode */ .xA)(item)) {
20035 item.$container = node;
20036 item.$containerProperty = name;
20037 item.$containerIndex = index;
20038 }
20039 });
20040 }
20041 else if ((0,_syntax_tree_js__WEBPACK_IMPORTED_MODULE_0__/* .isAstNode */ .xA)(value)) {
20042 value.$container = node;
20043 value.$containerProperty = name;
20044 }
20045 }
20046 }
20047 }
20048 /**
20049 * Walk along the hierarchy of containers from the given AST node to the root and return the first
20050 * node that matches the type predicate. If the start node itself matches, it is returned.
20051 * If no container matches, `undefined` is returned.
20052 */
20053 function getContainerOfType(node, typePredicate) {
20054 let item = node;
20055 while (item) {
20056 if (typePredicate(item)) {
20057 return item;
20058 }
20059 item = item.$container;
20060 }
20061 return undefined;
20062 }
20063 /**
20064 * Walk along the hierarchy of containers from the given AST node to the root and check for existence
20065 * of a container that matches the given predicate. The start node is included in the checks.
20066 */
20067 function hasContainerOfType(node, predicate) {
20068 let item = node;
20069 while (item) {
20070 if (predicate(item)) {
20071 return true;
20072 }
20073 item = item.$container;
20074 }
20075 return false;
20076 }
20077 /**
20078 * Retrieve the document in which the given AST node is contained. A reference to the document is
20079 * usually held by the root node of the AST.
20080 *
20081 * @throws an error if the node is not contained in a document.
20082 */
20083 function getDocument(node) {
20084 const rootNode = findRootNode(node);
20085 const result = rootNode.$document;
20086 if (!result) {
20087 throw new Error('AST node has no document.');
20088 }
20089 return result;
20090 }
20091 /**
20092 * Returns the root node of the given AST node by following the `$container` references.
20093 */
20094 function findRootNode(node) {
20095 while (node.$container) {
20096 node = node.$container;
20097 }
20098 return node;
20099 }
20100 /**
20101 * Create a stream of all AST nodes that are directly contained in the given node. This includes
20102 * single-valued as well as multi-valued (array) properties.
20103 */
20104 function streamContents(node, options) {
20105 if (!node) {
20106 throw new Error('Node must be an AstNode.');
20107 }
20108 const range = options === null || options === void 0 ? void 0 : options.range;
20109 return new _stream_js__WEBPACK_IMPORTED_MODULE_1__/* .StreamImpl */ .i(() => ({
20110 keys: Object.keys(node),
20111 keyIndex: 0,
20112 arrayIndex: 0
20113 }), state => {
20114 while (state.keyIndex < state.keys.length) {
20115 const property = state.keys[state.keyIndex];
20116 if (!property.startsWith('$')) {
20117 const value = node[property];
20118 if ((0,_syntax_tree_js__WEBPACK_IMPORTED_MODULE_0__/* .isAstNode */ .xA)(value)) {
20119 state.keyIndex++;
20120 if (isAstNodeInRange(value, range)) {
20121 return { done: false, value };
20122 }
20123 }
20124 else if (Array.isArray(value)) {
20125 while (state.arrayIndex < value.length) {
20126 const index = state.arrayIndex++;
20127 const element = value[index];
20128 if ((0,_syntax_tree_js__WEBPACK_IMPORTED_MODULE_0__/* .isAstNode */ .xA)(element) && isAstNodeInRange(element, range)) {
20129 return { done: false, value: element };
20130 }
20131 }
20132 state.arrayIndex = 0;
20133 }
20134 }
20135 state.keyIndex++;
20136 }
20137 return _stream_js__WEBPACK_IMPORTED_MODULE_1__/* .DONE_RESULT */ .Ry;
20138 });
20139 }
20140 /**
20141 * Create a stream of all AST nodes that are directly and indirectly contained in the given root node.
20142 * This does not include the root node itself.
20143 */
20144 function streamAllContents(root, options) {
20145 if (!root) {
20146 throw new Error('Root node must be an AstNode.');
20147 }
20148 return new _stream_js__WEBPACK_IMPORTED_MODULE_1__/* .TreeStreamImpl */ .i8(root, node => streamContents(node, options));
20149 }
20150 /**
20151 * Create a stream of all AST nodes that are directly and indirectly contained in the given root node,
20152 * including the root node itself.
20153 */
20154 function streamAst(root, options) {
20155 if (!root) {
20156 throw new Error('Root node must be an AstNode.');
20157 }
20158 else if ((options === null || options === void 0 ? void 0 : options.range) && !isAstNodeInRange(root, options.range)) {
20159 // Return an empty stream if the root node isn't in range
20160 return new _stream_js__WEBPACK_IMPORTED_MODULE_1__/* .TreeStreamImpl */ .i8(root, () => []);
20161 }
20162 return new _stream_js__WEBPACK_IMPORTED_MODULE_1__/* .TreeStreamImpl */ .i8(root, node => streamContents(node, options), { includeRoot: true });
20163 }
20164 function isAstNodeInRange(astNode, range) {
20165 var _a;
20166 if (!range) {
20167 return true;
20168 }
20169 const nodeRange = (_a = astNode.$cstNode) === null || _a === void 0 ? void 0 : _a.range;
20170 if (!nodeRange) {
20171 return false;
20172 }
20173 return (0,_cst_utils_js__WEBPACK_IMPORTED_MODULE_2__/* .inRange */ .Z2)(nodeRange, range);
20174 }
20175 /**
20176 * Create a stream of all cross-references that are held by the given AST node. This includes
20177 * single-valued as well as multi-valued (array) properties.
20178 */
20179 function streamReferences(node) {
20180 return new _stream_js__WEBPACK_IMPORTED_MODULE_1__/* .StreamImpl */ .i(() => ({
20181 keys: Object.keys(node),
20182 keyIndex: 0,
20183 arrayIndex: 0
20184 }), state => {
20185 while (state.keyIndex < state.keys.length) {
20186 const property = state.keys[state.keyIndex];
20187 if (!property.startsWith('$')) {
20188 const value = node[property];
20189 if ((0,_syntax_tree_js__WEBPACK_IMPORTED_MODULE_0__/* .isReference */ .Yk)(value)) {
20190 state.keyIndex++;
20191 return { done: false, value: { reference: value, container: node, property } };
20192 }
20193 else if (Array.isArray(value)) {
20194 while (state.arrayIndex < value.length) {
20195 const index = state.arrayIndex++;
20196 const element = value[index];
20197 if ((0,_syntax_tree_js__WEBPACK_IMPORTED_MODULE_0__/* .isReference */ .Yk)(element)) {
20198 return { done: false, value: { reference: element, container: node, property, index } };
20199 }
20200 }
20201 state.arrayIndex = 0;
20202 }
20203 }
20204 state.keyIndex++;
20205 }
20206 return _stream_js__WEBPACK_IMPORTED_MODULE_1__/* .DONE_RESULT */ .Ry;
20207 });
20208 }
20209 /**
20210 * Returns a Stream of references to the target node from the AstNode tree
20211 *
20212 * @param targetNode AstNode we are looking for
20213 * @param lookup AstNode where we search for references. If not provided, the root node of the document is used as the default value
20214 */
20215 function findLocalReferences(targetNode, lookup = getDocument(targetNode).parseResult.value) {
20216 const refs = [];
20217 streamAst(lookup).forEach(node => {
20218 streamReferences(node).forEach(refInfo => {
20219 if (refInfo.reference.ref === targetNode) {
20220 refs.push(refInfo.reference);
20221 }
20222 });
20223 });
20224 return stream(refs);
20225 }
20226 /**
20227 * Assigns all mandatory AST properties to the specified node.
20228 *
20229 * @param reflection Reflection object used to gather mandatory properties for the node.
20230 * @param node Specified node is modified in place and properties are directly assigned.
20231 */
20232 function assignMandatoryProperties(reflection, node) {
20233 const typeMetaData = reflection.getTypeMetaData(node.$type);
20234 const genericNode = node;
20235 for (const property of typeMetaData.properties) {
20236 // Only set the value if the property is not already set and if it has a default value
20237 if (property.defaultValue !== undefined && genericNode[property.name] === undefined) {
20238 genericNode[property.name] = copyDefaultValue(property.defaultValue);
20239 }
20240 }
20241 }
20242 function copyDefaultValue(propertyType) {
20243 if (Array.isArray(propertyType)) {
20244 return [...propertyType.map(copyDefaultValue)];
20245 }
20246 else {
20247 return propertyType;
20248 }
20249 }
20250 /**
20251 * Creates a deep copy of the specified AST node.
20252 * The resulting copy will only contain semantically relevant information, such as the `$type` property and AST properties.
20253 *
20254 * References are copied without resolved cross reference. The specified function is used to rebuild them.
20255 */
20256 function copyAstNode(node, buildReference) {
20257 const copy = { $type: node.$type };
20258 for (const [name, value] of Object.entries(node)) {
20259 if (!name.startsWith('$')) {
20260 if (isAstNode(value)) {
20261 copy[name] = copyAstNode(value, buildReference);
20262 }
20263 else if (isReference(value)) {
20264 copy[name] = buildReference(copy, name, value.$refNode, value.$refText);
20265 }
20266 else if (Array.isArray(value)) {
20267 const copiedArray = [];
20268 for (const element of value) {
20269 if (isAstNode(element)) {
20270 copiedArray.push(copyAstNode(element, buildReference));
20271 }
20272 else if (isReference(element)) {
20273 copiedArray.push(buildReference(copy, name, element.$refNode, element.$refText));
20274 }
20275 else {
20276 copiedArray.push(element);
20277 }
20278 }
20279 copy[name] = copiedArray;
20280 }
20281 else {
20282 copy[name] = value;
20283 }
20284 }
20285 }
20286 linkContentToContainer(copy);
20287 return copy;
20288 }
20289 //# sourceMappingURL=ast-utils.js.map
20290
20291 /***/ }),
20292
20293 /***/ 13871:
20294 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
20295
20296 "use strict";
20297 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
20298 /* harmony export */ LK: () => (/* binding */ findCommentNode),
20299 /* harmony export */ OB: () => (/* binding */ isChildNode),
20300 /* harmony export */ Z2: () => (/* binding */ inRange),
20301 /* harmony export */ _t: () => (/* binding */ streamCst),
20302 /* harmony export */ sp: () => (/* binding */ tokenToRange),
20303 /* harmony export */ uz: () => (/* binding */ DefaultNameRegexp),
20304 /* harmony export */ yn: () => (/* binding */ toDocumentSegment)
20305 /* harmony export */ });
20306 /* unused harmony exports flattenCst, RangeComparison, compareRange, findDeclarationNodeAtOffset, isCommentNode, findLeafNodeAtOffset, findLeafNodeBeforeOffset, getPreviousNode, getNextNode, getStartlineNode, getInteriorNodes */
20307 /* harmony import */ var _syntax_tree_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(91303);
20308 /* harmony import */ var _stream_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(99293);
20309 /******************************************************************************
20310 * Copyright 2021 TypeFox GmbH
20311 * This program and the accompanying materials are made available under the
20312 * terms of the MIT License, which is available in the project root.
20313 ******************************************************************************/
20314
20315
20316 /**
20317 * Create a stream of all CST nodes that are directly and indirectly contained in the given root node,
20318 * including the root node itself.
20319 */
20320 function streamCst(node) {
20321 return new _stream_js__WEBPACK_IMPORTED_MODULE_0__/* .TreeStreamImpl */ .i8(node, element => {
20322 if ((0,_syntax_tree_js__WEBPACK_IMPORTED_MODULE_1__/* .isCompositeCstNode */ .al)(element)) {
20323 return element.content;
20324 }
20325 else {
20326 return [];
20327 }
20328 }, { includeRoot: true });
20329 }
20330 /**
20331 * Create a stream of all leaf nodes that are directly and indirectly contained in the given root node.
20332 */
20333 function flattenCst(node) {
20334 return streamCst(node).filter(isLeafCstNode);
20335 }
20336 /**
20337 * Determines whether the specified cst node is a child of the specified parent node.
20338 */
20339 function isChildNode(child, parent) {
20340 while (child.container) {
20341 child = child.container;
20342 if (child === parent) {
20343 return true;
20344 }
20345 }
20346 return false;
20347 }
20348 function tokenToRange(token) {
20349 // Chevrotain uses 1-based indices everywhere
20350 // So we subtract 1 from every value to align with the LSP
20351 return {
20352 start: {
20353 character: token.startColumn - 1,
20354 line: token.startLine - 1
20355 },
20356 end: {
20357 character: token.endColumn, // endColumn uses the correct index
20358 line: token.endLine - 1
20359 }
20360 };
20361 }
20362 function toDocumentSegment(node) {
20363 if (!node) {
20364 return undefined;
20365 }
20366 const { offset, end, range } = node;
20367 return {
20368 range,
20369 offset,
20370 end,
20371 length: end - offset
20372 };
20373 }
20374 var RangeComparison;
20375 (function (RangeComparison) {
20376 RangeComparison[RangeComparison["Before"] = 0] = "Before";
20377 RangeComparison[RangeComparison["After"] = 1] = "After";
20378 RangeComparison[RangeComparison["OverlapFront"] = 2] = "OverlapFront";
20379 RangeComparison[RangeComparison["OverlapBack"] = 3] = "OverlapBack";
20380 RangeComparison[RangeComparison["Inside"] = 4] = "Inside";
20381 RangeComparison[RangeComparison["Outside"] = 5] = "Outside";
20382 })(RangeComparison || (RangeComparison = {}));
20383 function compareRange(range, to) {
20384 if (range.end.line < to.start.line || (range.end.line === to.start.line && range.end.character <= to.start.character)) {
20385 return RangeComparison.Before;
20386 }
20387 else if (range.start.line > to.end.line || (range.start.line === to.end.line && range.start.character >= to.end.character)) {
20388 return RangeComparison.After;
20389 }
20390 const startInside = range.start.line > to.start.line || (range.start.line === to.start.line && range.start.character >= to.start.character);
20391 const endInside = range.end.line < to.end.line || (range.end.line === to.end.line && range.end.character <= to.end.character);
20392 if (startInside && endInside) {
20393 return RangeComparison.Inside;
20394 }
20395 else if (startInside) {
20396 return RangeComparison.OverlapBack;
20397 }
20398 else if (endInside) {
20399 return RangeComparison.OverlapFront;
20400 }
20401 else {
20402 return RangeComparison.Outside;
20403 }
20404 }
20405 function inRange(range, to) {
20406 const comparison = compareRange(range, to);
20407 return comparison > RangeComparison.After;
20408 }
20409 // The \p{L} regex matches any unicode letter character, i.e. characters from non-english alphabets
20410 // Together with \w it matches any kind of character which can commonly appear in IDs
20411 const DefaultNameRegexp = /^[\w\p{L}]$/u;
20412 /**
20413 * Performs `findLeafNodeAtOffset` with a minor difference: When encountering a character that matches the `nameRegexp` argument,
20414 * it will instead return the leaf node at the `offset - 1` position.
20415 *
20416 * For LSP services, users expect that the declaration of an element is available if the cursor is directly after the element.
20417 */
20418 function findDeclarationNodeAtOffset(cstNode, offset, nameRegexp = DefaultNameRegexp) {
20419 if (cstNode) {
20420 if (offset > 0) {
20421 const localOffset = offset - cstNode.offset;
20422 const textAtOffset = cstNode.text.charAt(localOffset);
20423 if (!nameRegexp.test(textAtOffset)) {
20424 offset--;
20425 }
20426 }
20427 return findLeafNodeAtOffset(cstNode, offset);
20428 }
20429 return undefined;
20430 }
20431 function findCommentNode(cstNode, commentNames) {
20432 if (cstNode) {
20433 const previous = getPreviousNode(cstNode, true);
20434 if (previous && isCommentNode(previous, commentNames)) {
20435 return previous;
20436 }
20437 if ((0,_syntax_tree_js__WEBPACK_IMPORTED_MODULE_1__/* .isRootCstNode */ .U8)(cstNode)) {
20438 // Go from the first non-hidden node through all nodes in reverse order
20439 // We do this to find the comment node which directly precedes the root node
20440 const endIndex = cstNode.content.findIndex(e => !e.hidden);
20441 for (let i = endIndex - 1; i >= 0; i--) {
20442 const child = cstNode.content[i];
20443 if (isCommentNode(child, commentNames)) {
20444 return child;
20445 }
20446 }
20447 }
20448 }
20449 return undefined;
20450 }
20451 function isCommentNode(cstNode, commentNames) {
20452 return (0,_syntax_tree_js__WEBPACK_IMPORTED_MODULE_1__/* .isLeafCstNode */ .dm)(cstNode) && commentNames.includes(cstNode.tokenType.name);
20453 }
20454 /**
20455 * Finds the leaf CST node at the specified 0-based string offset.
20456 * Note that the given offset will be within the range of the returned leaf node.
20457 *
20458 * If the offset does not point to a CST node (but just white space), this method will return `undefined`.
20459 *
20460 * @param node The CST node to search through.
20461 * @param offset The specified offset.
20462 * @returns The CST node at the specified offset.
20463 */
20464 function findLeafNodeAtOffset(node, offset) {
20465 if (isLeafCstNode(node)) {
20466 return node;
20467 }
20468 else if (isCompositeCstNode(node)) {
20469 const searchResult = binarySearch(node, offset, false);
20470 if (searchResult) {
20471 return findLeafNodeAtOffset(searchResult, offset);
20472 }
20473 }
20474 return undefined;
20475 }
20476 /**
20477 * Finds the leaf CST node at the specified 0-based string offset.
20478 * If no CST node exists at the specified position, it will return the leaf node before it.
20479 *
20480 * If there is no leaf node before the specified offset, this method will return `undefined`.
20481 *
20482 * @param node The CST node to search through.
20483 * @param offset The specified offset.
20484 * @returns The CST node closest to the specified offset.
20485 */
20486 function findLeafNodeBeforeOffset(node, offset) {
20487 if (isLeafCstNode(node)) {
20488 return node;
20489 }
20490 else if (isCompositeCstNode(node)) {
20491 const searchResult = binarySearch(node, offset, true);
20492 if (searchResult) {
20493 return findLeafNodeBeforeOffset(searchResult, offset);
20494 }
20495 }
20496 return undefined;
20497 }
20498 function binarySearch(node, offset, closest) {
20499 let left = 0;
20500 let right = node.content.length - 1;
20501 let closestNode = undefined;
20502 while (left <= right) {
20503 const middle = Math.floor((left + right) / 2);
20504 const middleNode = node.content[middle];
20505 if (middleNode.offset <= offset && middleNode.end > offset) {
20506 // Found an exact match
20507 return middleNode;
20508 }
20509 if (middleNode.end <= offset) {
20510 // Update the closest node (less than offset) and move to the right half
20511 closestNode = closest ? middleNode : undefined;
20512 left = middle + 1;
20513 }
20514 else {
20515 // Move to the left half
20516 right = middle - 1;
20517 }
20518 }
20519 return closestNode;
20520 }
20521 function getPreviousNode(node, hidden = true) {
20522 while (node.container) {
20523 const parent = node.container;
20524 let index = parent.content.indexOf(node);
20525 while (index > 0) {
20526 index--;
20527 const previous = parent.content[index];
20528 if (hidden || !previous.hidden) {
20529 return previous;
20530 }
20531 }
20532 node = parent;
20533 }
20534 return undefined;
20535 }
20536 function getNextNode(node, hidden = true) {
20537 while (node.container) {
20538 const parent = node.container;
20539 let index = parent.content.indexOf(node);
20540 const last = parent.content.length - 1;
20541 while (index < last) {
20542 index++;
20543 const next = parent.content[index];
20544 if (hidden || !next.hidden) {
20545 return next;
20546 }
20547 }
20548 node = parent;
20549 }
20550 return undefined;
20551 }
20552 function getStartlineNode(node) {
20553 if (node.range.start.character === 0) {
20554 return node;
20555 }
20556 const line = node.range.start.line;
20557 let last = node;
20558 let index;
20559 while (node.container) {
20560 const parent = node.container;
20561 const selfIndex = index !== null && index !== void 0 ? index : parent.content.indexOf(node);
20562 if (selfIndex === 0) {
20563 node = parent;
20564 index = undefined;
20565 }
20566 else {
20567 index = selfIndex - 1;
20568 node = parent.content[index];
20569 }
20570 if (node.range.start.line !== line) {
20571 break;
20572 }
20573 last = node;
20574 }
20575 return last;
20576 }
20577 function getInteriorNodes(start, end) {
20578 const commonParent = getCommonParent(start, end);
20579 if (!commonParent) {
20580 return [];
20581 }
20582 return commonParent.parent.content.slice(commonParent.a + 1, commonParent.b);
20583 }
20584 function getCommonParent(a, b) {
20585 const aParents = getParentChain(a);
20586 const bParents = getParentChain(b);
20587 let current;
20588 for (let i = 0; i < aParents.length && i < bParents.length; i++) {
20589 const aParent = aParents[i];
20590 const bParent = bParents[i];
20591 if (aParent.parent === bParent.parent) {
20592 current = {
20593 parent: aParent.parent,
20594 a: aParent.index,
20595 b: bParent.index
20596 };
20597 }
20598 else {
20599 break;
20600 }
20601 }
20602 return current;
20603 }
20604 function getParentChain(node) {
20605 const chain = [];
20606 while (node.container) {
20607 const parent = node.container;
20608 const index = parent.content.indexOf(node);
20609 chain.push({
20610 parent,
20611 index
20612 });
20613 node = parent;
20614 }
20615 return chain.reverse();
20616 }
20617 //# sourceMappingURL=cst-utils.js.map
20618
20619 /***/ }),
20620
20621 /***/ 45209:
20622 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
20623
20624 "use strict";
20625 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
20626 /* harmony export */ U: () => (/* binding */ assertUnreachable),
20627 /* harmony export */ h: () => (/* binding */ ErrorWithLocation)
20628 /* harmony export */ });
20629 /******************************************************************************
20630 * Copyright 2021 TypeFox GmbH
20631 * This program and the accompanying materials are made available under the
20632 * terms of the MIT License, which is available in the project root.
20633 ******************************************************************************/
20634 class ErrorWithLocation extends Error {
20635 constructor(node, message) {
20636 super(node ? `${message} at ${node.range.start.line}:${node.range.start.character}` : message);
20637 }
20638 }
20639 function assertUnreachable(_) {
20640 throw new Error('Error! The input value was not handled.');
20641 }
20642 //# sourceMappingURL=errors.js.map
20643
20644 /***/ }),
20645
20646 /***/ 30447:
20647 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
20648
20649 "use strict";
20650 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
20651 /* harmony export */ $G: () => (/* binding */ getExplicitRuleType),
20652 /* harmony export */ EL: () => (/* binding */ findNodesForProperty),
20653 /* harmony export */ UP: () => (/* binding */ isDataTypeRule),
20654 /* harmony export */ VD: () => (/* binding */ getAllReachableRules),
20655 /* harmony export */ eN: () => (/* binding */ getCrossReferenceTerminal),
20656 /* harmony export */ h7: () => (/* binding */ findAssignment),
20657 /* harmony export */ ib: () => (/* binding */ findNameAssignment),
20658 /* harmony export */ lA: () => (/* binding */ findNodeForKeyword),
20659 /* harmony export */ mJ: () => (/* binding */ getRuleType),
20660 /* harmony export */ md: () => (/* binding */ isCommentTerminal),
20661 /* harmony export */ s1: () => (/* binding */ terminalRegex),
20662 /* harmony export */ vb: () => (/* binding */ findNodeForProperty),
20663 /* harmony export */ z$: () => (/* binding */ getTypeName)
20664 /* harmony export */ });
20665 /* unused harmony exports getEntryRule, getHiddenRules, findNodesForKeyword, findNodesForKeywordInternal, getActionAtElement, isOptionalCardinality, isArrayCardinality, isArrayOperator, isDataType, getActionType, getRuleTypeName */
20666 /* harmony import */ var _utils_errors_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(45209);
20667 /* harmony import */ var _languages_generated_ast_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(34905);
20668 /* harmony import */ var _syntax_tree_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(91303);
20669 /* harmony import */ var _ast_utils_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(74857);
20670 /* harmony import */ var _cst_utils_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(13871);
20671 /* harmony import */ var _regexp_utils_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(43078);
20672 /******************************************************************************
20673 * Copyright 2021-2022 TypeFox GmbH
20674 * This program and the accompanying materials are made available under the
20675 * terms of the MIT License, which is available in the project root.
20676 ******************************************************************************/
20677
20678
20679
20680
20681
20682
20683 /**
20684 * Returns the entry rule of the given grammar, if any. If the grammar file does not contain an entry rule,
20685 * the result is `undefined`.
20686 */
20687 function getEntryRule(grammar) {
20688 return grammar.rules.find(e => _languages_generated_ast_js__WEBPACK_IMPORTED_MODULE_0__/* .isParserRule */ .F9(e) && e.entry);
20689 }
20690 /**
20691 * Returns all hidden terminal rules of the given grammar, if any.
20692 */
20693 function getHiddenRules(grammar) {
20694 return grammar.rules.filter((e) => _languages_generated_ast_js__WEBPACK_IMPORTED_MODULE_0__/* .isTerminalRule */ .MS(e) && e.hidden);
20695 }
20696 /**
20697 * Returns all rules that can be reached from the topmost rules of the specified grammar (entry and hidden terminal rules).
20698 *
20699 * @param grammar The grammar that contains all rules
20700 * @param allTerminals Whether or not to include terminals that are referenced only by other terminals
20701 * @returns A list of referenced parser and terminal rules. If the grammar contains no entry rule,
20702 * this function returns all rules of the specified grammar.
20703 */
20704 function getAllReachableRules(grammar, allTerminals) {
20705 const ruleNames = new Set();
20706 const entryRule = getEntryRule(grammar);
20707 if (!entryRule) {
20708 return new Set(grammar.rules);
20709 }
20710 const topMostRules = [entryRule].concat(getHiddenRules(grammar));
20711 for (const rule of topMostRules) {
20712 ruleDfs(rule, ruleNames, allTerminals);
20713 }
20714 const rules = new Set();
20715 for (const rule of grammar.rules) {
20716 if (ruleNames.has(rule.name) || (_languages_generated_ast_js__WEBPACK_IMPORTED_MODULE_0__/* .isTerminalRule */ .MS(rule) && rule.hidden)) {
20717 rules.add(rule);
20718 }
20719 }
20720 return rules;
20721 }
20722 function ruleDfs(rule, visitedSet, allTerminals) {
20723 visitedSet.add(rule.name);
20724 (0,_ast_utils_js__WEBPACK_IMPORTED_MODULE_1__/* .streamAllContents */ .VY)(rule).forEach(node => {
20725 if (_languages_generated_ast_js__WEBPACK_IMPORTED_MODULE_0__/* .isRuleCall */ .t3(node) || (allTerminals && _languages_generated_ast_js__WEBPACK_IMPORTED_MODULE_0__/* .isTerminalRuleCall */ .gf(node))) {
20726 const refRule = node.rule.ref;
20727 if (refRule && !visitedSet.has(refRule.name)) {
20728 ruleDfs(refRule, visitedSet, allTerminals);
20729 }
20730 }
20731 });
20732 }
20733 /**
20734 * Determines the grammar expression used to parse a cross-reference (usually a reference to a terminal rule).
20735 * A cross-reference can declare this expression explicitly in the form `[Type : Terminal]`, but if `Terminal`
20736 * is omitted, this function attempts to infer it from the name of the referenced `Type` (using `findNameAssignment`).
20737 *
20738 * Returns the grammar expression used to parse the given cross-reference, or `undefined` if it is not declared
20739 * and cannot be inferred.
20740 */
20741 function getCrossReferenceTerminal(crossRef) {
20742 if (crossRef.terminal) {
20743 return crossRef.terminal;
20744 }
20745 else if (crossRef.type.ref) {
20746 const nameAssigment = findNameAssignment(crossRef.type.ref);
20747 return nameAssigment === null || nameAssigment === void 0 ? void 0 : nameAssigment.terminal;
20748 }
20749 return undefined;
20750 }
20751 /**
20752 * Determines whether the given terminal rule represents a comment. This is true if the rule is marked
20753 * as `hidden` and it does not match white space. This means every hidden token (i.e. excluded from the AST)
20754 * that contains visible characters is considered a comment.
20755 */
20756 function isCommentTerminal(terminalRule) {
20757 return terminalRule.hidden && !(0,_regexp_utils_js__WEBPACK_IMPORTED_MODULE_2__/* .isWhitespace */ .cb)(terminalRegex(terminalRule));
20758 }
20759 /**
20760 * Find all CST nodes within the given node that contribute to the specified property.
20761 *
20762 * @param node A CST node in which to look for property assignments. If this is undefined, the result is an empty array.
20763 * @param property A property name of the constructed AST node. If this is undefined, the result is an empty array.
20764 */
20765 function findNodesForProperty(node, property) {
20766 if (!node || !property) {
20767 return [];
20768 }
20769 return findNodesForPropertyInternal(node, property, node.astNode, true);
20770 }
20771 /**
20772 * Find a single CST node within the given node that contributes to the specified property.
20773 *
20774 * @param node A CST node in which to look for property assignments. If this is undefined, the result is `undefined`.
20775 * @param property A property name of the constructed AST node. If this is undefined, the result is `undefined`.
20776 * @param index If no index is specified or the index is less than zero, the first found node is returned. If the
20777 * specified index exceeds the number of assignments to the property, the last found node is returned. Otherwise,
20778 * the node with the specified index is returned.
20779 */
20780 function findNodeForProperty(node, property, index) {
20781 if (!node || !property) {
20782 return undefined;
20783 }
20784 const nodes = findNodesForPropertyInternal(node, property, node.astNode, true);
20785 if (nodes.length === 0) {
20786 return undefined;
20787 }
20788 if (index !== undefined) {
20789 index = Math.max(0, Math.min(index, nodes.length - 1));
20790 }
20791 else {
20792 index = 0;
20793 }
20794 return nodes[index];
20795 }
20796 function findNodesForPropertyInternal(node, property, element, first) {
20797 if (!first) {
20798 const nodeFeature = (0,_ast_utils_js__WEBPACK_IMPORTED_MODULE_1__/* .getContainerOfType */ .V_)(node.grammarSource, _languages_generated_ast_js__WEBPACK_IMPORTED_MODULE_0__/* .isAssignment */ .B7);
20799 if (nodeFeature && nodeFeature.feature === property) {
20800 return [node];
20801 }
20802 }
20803 if ((0,_syntax_tree_js__WEBPACK_IMPORTED_MODULE_3__/* .isCompositeCstNode */ .al)(node) && node.astNode === element) {
20804 return node.content.flatMap(e => findNodesForPropertyInternal(e, property, element, false));
20805 }
20806 return [];
20807 }
20808 /**
20809 * Find all CST nodes within the given node that correspond to the specified keyword.
20810 *
20811 * @param node A CST node in which to look for keywords. If this is undefined, the result is an empty array.
20812 * @param keyword A keyword as specified in the grammar.
20813 */
20814 function findNodesForKeyword(node, keyword) {
20815 if (!node) {
20816 return [];
20817 }
20818 return findNodesForKeywordInternal(node, keyword, node === null || node === void 0 ? void 0 : node.astNode);
20819 }
20820 /**
20821 * Find a single CST node within the given node that corresponds to the specified keyword.
20822 *
20823 * @param node A CST node in which to look for keywords. If this is undefined, the result is `undefined`.
20824 * @param keyword A keyword as specified in the grammar.
20825 * @param index If no index is specified or the index is less than zero, the first found node is returned. If the
20826 * specified index exceeds the number of keyword occurrences, the last found node is returned. Otherwise,
20827 * the node with the specified index is returned.
20828 */
20829 function findNodeForKeyword(node, keyword, index) {
20830 if (!node) {
20831 return undefined;
20832 }
20833 const nodes = findNodesForKeywordInternal(node, keyword, node === null || node === void 0 ? void 0 : node.astNode);
20834 if (nodes.length === 0) {
20835 return undefined;
20836 }
20837 if (index !== undefined) {
20838 index = Math.max(0, Math.min(index, nodes.length - 1));
20839 }
20840 else {
20841 index = 0;
20842 }
20843 return nodes[index];
20844 }
20845 function findNodesForKeywordInternal(node, keyword, element) {
20846 if (node.astNode !== element) {
20847 return [];
20848 }
20849 if (_languages_generated_ast_js__WEBPACK_IMPORTED_MODULE_0__/* .isKeyword */ .p1(node.grammarSource) && node.grammarSource.value === keyword) {
20850 return [node];
20851 }
20852 const treeIterator = (0,_cst_utils_js__WEBPACK_IMPORTED_MODULE_4__/* .streamCst */ ._t)(node).iterator();
20853 let result;
20854 const keywordNodes = [];
20855 do {
20856 result = treeIterator.next();
20857 if (!result.done) {
20858 const childNode = result.value;
20859 if (childNode.astNode === element) {
20860 if (_languages_generated_ast_js__WEBPACK_IMPORTED_MODULE_0__/* .isKeyword */ .p1(childNode.grammarSource) && childNode.grammarSource.value === keyword) {
20861 keywordNodes.push(childNode);
20862 }
20863 }
20864 else {
20865 treeIterator.prune();
20866 }
20867 }
20868 } while (!result.done);
20869 return keywordNodes;
20870 }
20871 /**
20872 * If the given CST node was parsed in the context of a property assignment, the respective `Assignment` grammar
20873 * node is returned. If no assignment is found, the result is `undefined`.
20874 *
20875 * @param cstNode A CST node for which to find a property assignment.
20876 */
20877 function findAssignment(cstNode) {
20878 var _a;
20879 const astNode = cstNode.astNode;
20880 // Only search until the ast node of the parent cst node is no longer the original ast node
20881 // This would make us jump to a preceding rule call, which contains only unrelated assignments
20882 while (astNode === ((_a = cstNode.container) === null || _a === void 0 ? void 0 : _a.astNode)) {
20883 const assignment = (0,_ast_utils_js__WEBPACK_IMPORTED_MODULE_1__/* .getContainerOfType */ .V_)(cstNode.grammarSource, _languages_generated_ast_js__WEBPACK_IMPORTED_MODULE_0__/* .isAssignment */ .B7);
20884 if (assignment) {
20885 return assignment;
20886 }
20887 cstNode = cstNode.container;
20888 }
20889 return undefined;
20890 }
20891 /**
20892 * Find an assignment to the `name` property for the given grammar type. This requires the `type` to be inferred
20893 * from a parser rule, and that rule must contain an assignment to the `name` property. In all other cases,
20894 * this function returns `undefined`.
20895 */
20896 function findNameAssignment(type) {
20897 let startNode = type;
20898 if (_languages_generated_ast_js__WEBPACK_IMPORTED_MODULE_0__/* .isInferredType */ .S_(startNode)) {
20899 // for inferred types, the location to start searching for the name-assignment is different
20900 if (_languages_generated_ast_js__WEBPACK_IMPORTED_MODULE_0__/* .isAction */ .LG(startNode.$container)) {
20901 // a type which is explicitly inferred by an action: investigate the sibbling of the Action node, i.e. start searching at the Action's parent
20902 startNode = startNode.$container.$container;
20903 }
20904 else if (_languages_generated_ast_js__WEBPACK_IMPORTED_MODULE_0__/* .isParserRule */ .F9(startNode.$container)) {
20905 // investigate the parser rule with the explicitly inferred type
20906 startNode = startNode.$container;
20907 }
20908 else {
20909 (0,_utils_errors_js__WEBPACK_IMPORTED_MODULE_5__/* .assertUnreachable */ .U)(startNode.$container);
20910 }
20911 }
20912 return findNameAssignmentInternal(type, startNode, new Map());
20913 }
20914 function findNameAssignmentInternal(type, startNode, cache) {
20915 var _a;
20916 // the cache is only required to prevent infinite loops
20917 function go(node, refType) {
20918 let childAssignment = undefined;
20919 const parentAssignment = (0,_ast_utils_js__WEBPACK_IMPORTED_MODULE_1__/* .getContainerOfType */ .V_)(node, _languages_generated_ast_js__WEBPACK_IMPORTED_MODULE_0__/* .isAssignment */ .B7);
20920 // No parent assignment implies unassigned rule call
20921 if (!parentAssignment) {
20922 childAssignment = findNameAssignmentInternal(refType, refType, cache);
20923 }
20924 cache.set(type, childAssignment);
20925 return childAssignment;
20926 }
20927 if (cache.has(type)) {
20928 return cache.get(type);
20929 }
20930 cache.set(type, undefined);
20931 for (const node of (0,_ast_utils_js__WEBPACK_IMPORTED_MODULE_1__/* .streamAllContents */ .VY)(startNode)) {
20932 if (_languages_generated_ast_js__WEBPACK_IMPORTED_MODULE_0__/* .isAssignment */ .B7(node) && node.feature.toLowerCase() === 'name') {
20933 cache.set(type, node);
20934 return node;
20935 }
20936 else if (_languages_generated_ast_js__WEBPACK_IMPORTED_MODULE_0__/* .isRuleCall */ .t3(node) && _languages_generated_ast_js__WEBPACK_IMPORTED_MODULE_0__/* .isParserRule */ .F9(node.rule.ref)) {
20937 return go(node, node.rule.ref);
20938 }
20939 else if (_languages_generated_ast_js__WEBPACK_IMPORTED_MODULE_0__/* .isSimpleType */ .Iy(node) && ((_a = node.typeRef) === null || _a === void 0 ? void 0 : _a.ref)) {
20940 return go(node, node.typeRef.ref);
20941 }
20942 }
20943 return undefined;
20944 }
20945 function getActionAtElement(element) {
20946 const parent = element.$container;
20947 if (ast.isGroup(parent)) {
20948 const elements = parent.elements;
20949 const index = elements.indexOf(element);
20950 for (let i = index - 1; i >= 0; i--) {
20951 const item = elements[i];
20952 if (ast.isAction(item)) {
20953 return item;
20954 }
20955 else {
20956 const action = streamAllContents(elements[i]).find(ast.isAction);
20957 if (action) {
20958 return action;
20959 }
20960 }
20961 }
20962 }
20963 if (ast.isAbstractElement(parent)) {
20964 return getActionAtElement(parent);
20965 }
20966 else {
20967 return undefined;
20968 }
20969 }
20970 function isOptionalCardinality(cardinality, element) {
20971 return cardinality === '?' || cardinality === '*' || (ast.isGroup(element) && Boolean(element.guardCondition));
20972 }
20973 function isArrayCardinality(cardinality) {
20974 return cardinality === '*' || cardinality === '+';
20975 }
20976 function isArrayOperator(operator) {
20977 return operator === '+=';
20978 }
20979 /**
20980 * Determines whether the given parser rule is a _data type rule_, meaning that it has a
20981 * primitive return type like `number`, `boolean`, etc.
20982 */
20983 function isDataTypeRule(rule) {
20984 return isDataTypeRuleInternal(rule, new Set());
20985 }
20986 function isDataTypeRuleInternal(rule, visited) {
20987 if (visited.has(rule)) {
20988 return true;
20989 }
20990 else {
20991 visited.add(rule);
20992 }
20993 for (const node of (0,_ast_utils_js__WEBPACK_IMPORTED_MODULE_1__/* .streamAllContents */ .VY)(rule)) {
20994 if (_languages_generated_ast_js__WEBPACK_IMPORTED_MODULE_0__/* .isRuleCall */ .t3(node)) {
20995 if (!node.rule.ref) {
20996 // RuleCall to unresolved rule. Don't assume `rule` is a DataType rule.
20997 return false;
20998 }
20999 if (_languages_generated_ast_js__WEBPACK_IMPORTED_MODULE_0__/* .isParserRule */ .F9(node.rule.ref) && !isDataTypeRuleInternal(node.rule.ref, visited)) {
21000 return false;
21001 }
21002 }
21003 else if (_languages_generated_ast_js__WEBPACK_IMPORTED_MODULE_0__/* .isAssignment */ .B7(node)) {
21004 return false;
21005 }
21006 else if (_languages_generated_ast_js__WEBPACK_IMPORTED_MODULE_0__/* .isAction */ .LG(node)) {
21007 return false;
21008 }
21009 }
21010 return Boolean(rule.definition);
21011 }
21012 function isDataType(type) {
21013 return isDataTypeInternal(type.type, new Set());
21014 }
21015 function isDataTypeInternal(type, visited) {
21016 if (visited.has(type)) {
21017 return true;
21018 }
21019 else {
21020 visited.add(type);
21021 }
21022 if (ast.isArrayType(type)) {
21023 return false;
21024 }
21025 else if (ast.isReferenceType(type)) {
21026 return false;
21027 }
21028 else if (ast.isUnionType(type)) {
21029 return type.types.every(e => isDataTypeInternal(e, visited));
21030 }
21031 else if (ast.isSimpleType(type)) {
21032 if (type.primitiveType !== undefined) {
21033 return true;
21034 }
21035 else if (type.stringType !== undefined) {
21036 return true;
21037 }
21038 else if (type.typeRef !== undefined) {
21039 const ref = type.typeRef.ref;
21040 if (ast.isType(ref)) {
21041 return isDataTypeInternal(ref.type, visited);
21042 }
21043 else {
21044 return false;
21045 }
21046 }
21047 else {
21048 return false;
21049 }
21050 }
21051 else {
21052 return false;
21053 }
21054 }
21055 function getExplicitRuleType(rule) {
21056 if (rule.inferredType) {
21057 return rule.inferredType.name;
21058 }
21059 else if (rule.dataType) {
21060 return rule.dataType;
21061 }
21062 else if (rule.returnType) {
21063 const refType = rule.returnType.ref;
21064 if (refType) {
21065 // check if we need to check Action as return type
21066 if (_languages_generated_ast_js__WEBPACK_IMPORTED_MODULE_0__/* .isParserRule */ .F9(refType)) {
21067 return refType.name;
21068 }
21069 else if (_languages_generated_ast_js__WEBPACK_IMPORTED_MODULE_0__/* .isInterface */ .QV(refType) || _languages_generated_ast_js__WEBPACK_IMPORTED_MODULE_0__/* .isType */ .P9(refType)) {
21070 return refType.name;
21071 }
21072 }
21073 }
21074 return undefined;
21075 }
21076 function getTypeName(type) {
21077 var _a;
21078 if (_languages_generated_ast_js__WEBPACK_IMPORTED_MODULE_0__/* .isParserRule */ .F9(type)) {
21079 return isDataTypeRule(type) ? type.name : (_a = getExplicitRuleType(type)) !== null && _a !== void 0 ? _a : type.name;
21080 }
21081 else if (_languages_generated_ast_js__WEBPACK_IMPORTED_MODULE_0__/* .isInterface */ .QV(type) || _languages_generated_ast_js__WEBPACK_IMPORTED_MODULE_0__/* .isType */ .P9(type) || _languages_generated_ast_js__WEBPACK_IMPORTED_MODULE_0__/* .isReturnType */ .Mp(type)) {
21082 return type.name;
21083 }
21084 else if (_languages_generated_ast_js__WEBPACK_IMPORTED_MODULE_0__/* .isAction */ .LG(type)) {
21085 const actionType = getActionType(type);
21086 if (actionType) {
21087 return actionType;
21088 }
21089 }
21090 else if (_languages_generated_ast_js__WEBPACK_IMPORTED_MODULE_0__/* .isInferredType */ .S_(type)) {
21091 return type.name;
21092 }
21093 throw new Error('Cannot get name of Unknown Type');
21094 }
21095 function getActionType(action) {
21096 var _a;
21097 if (action.inferredType) {
21098 return action.inferredType.name;
21099 }
21100 else if ((_a = action.type) === null || _a === void 0 ? void 0 : _a.ref) {
21101 return getTypeName(action.type.ref);
21102 }
21103 return undefined; // not inferring and not referencing a valid type
21104 }
21105 /**
21106 * This function is used at development time (for code generation and the internal type system) to get the type of the AST node produced by the given rule.
21107 * For data type rules, the name of the rule is returned,
21108 * e.g. "INT_value returns number: MY_INT;" returns "INT_value".
21109 * @param rule the given rule
21110 * @returns the name of the AST node type of the rule
21111 */
21112 function getRuleTypeName(rule) {
21113 var _a, _b, _c;
21114 if (ast.isTerminalRule(rule)) {
21115 return (_b = (_a = rule.type) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : 'string';
21116 }
21117 else {
21118 return isDataTypeRule(rule) ? rule.name : (_c = getExplicitRuleType(rule)) !== null && _c !== void 0 ? _c : rule.name;
21119 }
21120 }
21121 /**
21122 * This function is used at runtime to get the actual type of the values produced by the given rule at runtime.
21123 * For data type rules, the name of the declared return type of the rule is returned (if any),
21124 * e.g. "INT_value returns number: MY_INT;" returns "number".
21125 * @param rule the given rule
21126 * @returns the name of the type of the produced values of the rule at runtime
21127 */
21128 function getRuleType(rule) {
21129 var _a, _b, _c;
21130 if (_languages_generated_ast_js__WEBPACK_IMPORTED_MODULE_0__/* .isTerminalRule */ .MS(rule)) {
21131 return (_b = (_a = rule.type) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : 'string';
21132 }
21133 else {
21134 return (_c = getExplicitRuleType(rule)) !== null && _c !== void 0 ? _c : rule.name;
21135 }
21136 }
21137 function terminalRegex(terminalRule) {
21138 const flags = {
21139 s: false,
21140 i: false,
21141 u: false
21142 };
21143 const source = abstractElementToRegex(terminalRule.definition, flags);
21144 const flagText = Object.entries(flags).filter(([, value]) => value).map(([name]) => name).join('');
21145 return new RegExp(source, flagText);
21146 }
21147 // Using [\s\S]* allows to match everything, compared to . which doesn't match line terminators
21148 const WILDCARD = /[\s\S]/.source;
21149 function abstractElementToRegex(element, flags) {
21150 if (_languages_generated_ast_js__WEBPACK_IMPORTED_MODULE_0__/* .isTerminalAlternatives */ .V7(element)) {
21151 return terminalAlternativesToRegex(element);
21152 }
21153 else if (_languages_generated_ast_js__WEBPACK_IMPORTED_MODULE_0__/* .isTerminalGroup */ .X9(element)) {
21154 return terminalGroupToRegex(element);
21155 }
21156 else if (_languages_generated_ast_js__WEBPACK_IMPORTED_MODULE_0__/* .isCharacterRange */ .Bf(element)) {
21157 return characterRangeToRegex(element);
21158 }
21159 else if (_languages_generated_ast_js__WEBPACK_IMPORTED_MODULE_0__/* .isTerminalRuleCall */ .gf(element)) {
21160 const rule = element.rule.ref;
21161 if (!rule) {
21162 throw new Error('Missing rule reference.');
21163 }
21164 return withCardinality(abstractElementToRegex(rule.definition), {
21165 cardinality: element.cardinality,
21166 lookahead: element.lookahead
21167 });
21168 }
21169 else if (_languages_generated_ast_js__WEBPACK_IMPORTED_MODULE_0__/* .isNegatedToken */ .Bi(element)) {
21170 return negateTokenToRegex(element);
21171 }
21172 else if (_languages_generated_ast_js__WEBPACK_IMPORTED_MODULE_0__/* .isUntilToken */ .OG(element)) {
21173 return untilTokenToRegex(element);
21174 }
21175 else if (_languages_generated_ast_js__WEBPACK_IMPORTED_MODULE_0__/* .isRegexToken */ .Sg(element)) {
21176 const lastSlash = element.regex.lastIndexOf('/');
21177 const source = element.regex.substring(1, lastSlash);
21178 const regexFlags = element.regex.substring(lastSlash + 1);
21179 if (flags) {
21180 flags.i = regexFlags.includes('i');
21181 flags.s = regexFlags.includes('s');
21182 flags.u = regexFlags.includes('u');
21183 }
21184 return withCardinality(source, {
21185 cardinality: element.cardinality,
21186 lookahead: element.lookahead,
21187 wrap: false
21188 });
21189 }
21190 else if (_languages_generated_ast_js__WEBPACK_IMPORTED_MODULE_0__/* .isWildcard */ .qm(element)) {
21191 return withCardinality(WILDCARD, {
21192 cardinality: element.cardinality,
21193 lookahead: element.lookahead
21194 });
21195 }
21196 else {
21197 throw new Error(`Invalid terminal element: ${element === null || element === void 0 ? void 0 : element.$type}`);
21198 }
21199 }
21200 function terminalAlternativesToRegex(alternatives) {
21201 return withCardinality(alternatives.elements.map(e => abstractElementToRegex(e)).join('|'), {
21202 cardinality: alternatives.cardinality,
21203 lookahead: alternatives.lookahead
21204 });
21205 }
21206 function terminalGroupToRegex(group) {
21207 return withCardinality(group.elements.map(e => abstractElementToRegex(e)).join(''), {
21208 cardinality: group.cardinality,
21209 lookahead: group.lookahead
21210 });
21211 }
21212 function untilTokenToRegex(until) {
21213 return withCardinality(`${WILDCARD}*?${abstractElementToRegex(until.terminal)}`, {
21214 cardinality: until.cardinality,
21215 lookahead: until.lookahead
21216 });
21217 }
21218 function negateTokenToRegex(negate) {
21219 return withCardinality(`(?!${abstractElementToRegex(negate.terminal)})${WILDCARD}*?`, {
21220 cardinality: negate.cardinality,
21221 lookahead: negate.lookahead
21222 });
21223 }
21224 function characterRangeToRegex(range) {
21225 if (range.right) {
21226 return withCardinality(`[${keywordToRegex(range.left)}-${keywordToRegex(range.right)}]`, {
21227 cardinality: range.cardinality,
21228 lookahead: range.lookahead,
21229 wrap: false
21230 });
21231 }
21232 return withCardinality(keywordToRegex(range.left), {
21233 cardinality: range.cardinality,
21234 lookahead: range.lookahead,
21235 wrap: false
21236 });
21237 }
21238 function keywordToRegex(keyword) {
21239 return (0,_regexp_utils_js__WEBPACK_IMPORTED_MODULE_2__/* .escapeRegExp */ .hr)(keyword.value);
21240 }
21241 function withCardinality(regex, options) {
21242 var _a;
21243 if (options.wrap !== false || options.lookahead) {
21244 regex = `(${(_a = options.lookahead) !== null && _a !== void 0 ? _a : ''}${regex})`;
21245 }
21246 if (options.cardinality) {
21247 return `${regex}${options.cardinality}`;
21248 }
21249 return regex;
21250 }
21251 //# sourceMappingURL=grammar-utils.js.map
21252
21253 /***/ }),
21254
21255 /***/ 43078:
21256 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
21257
21258 "use strict";
21259 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
21260 /* harmony export */ K0: () => (/* binding */ NEWLINE_REGEXP),
21261 /* harmony export */ Rn: () => (/* binding */ isMultilineComment),
21262 /* harmony export */ XC: () => (/* binding */ partialMatches),
21263 /* harmony export */ cb: () => (/* binding */ isWhitespace),
21264 /* harmony export */ cp: () => (/* binding */ getCaseInsensitivePattern),
21265 /* harmony export */ hr: () => (/* binding */ escapeRegExp)
21266 /* harmony export */ });
21267 /* unused harmony exports getTerminalParts, whitespaceCharacters, partialRegExp */
21268 /* harmony import */ var _chevrotain_regexp_to_ast__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(77647);
21269 /******************************************************************************
21270 * Copyright 2021 TypeFox GmbH
21271 * This program and the accompanying materials are made available under the
21272 * terms of the MIT License, which is available in the project root.
21273 ******************************************************************************/
21274
21275 const NEWLINE_REGEXP = /\r?\n/gm;
21276 const regexpParser = new _chevrotain_regexp_to_ast__WEBPACK_IMPORTED_MODULE_0__/* .RegExpParser */ .O();
21277 /**
21278 * This class is in charge of heuristically identifying start/end tokens of terminals.
21279 *
21280 * The way this works is by doing the following:
21281 * 1. Traverse the regular expression in the "start state"
21282 * 2. Add any encountered sets/single characters to the "start regexp"
21283 * 3. Once we encounter any variable-length content (i.e. with quantifiers such as +/?/*), we enter the "end state"
21284 * 4. In the end state, any sets/single characters are added to an "end stack".
21285 * 5. If we re-encounter any variable-length content we reset the end stack
21286 * 6. We continue visiting the regex until the end, reseting the end stack and rebuilding it as necessary
21287 *
21288 * After traversing a regular expression the `startRegexp/endRegexp` properties allow access to the stored start/end of the terminal
21289 */
21290 class TerminalRegExpVisitor extends _chevrotain_regexp_to_ast__WEBPACK_IMPORTED_MODULE_0__/* .BaseRegExpVisitor */ .e {
21291 constructor() {
21292 super(...arguments);
21293 this.isStarting = true;
21294 this.endRegexpStack = [];
21295 this.multiline = false;
21296 }
21297 get endRegex() {
21298 return this.endRegexpStack.join('');
21299 }
21300 reset(regex) {
21301 this.multiline = false;
21302 this.regex = regex;
21303 this.startRegexp = '';
21304 this.isStarting = true;
21305 this.endRegexpStack = [];
21306 }
21307 visitGroup(node) {
21308 if (node.quantifier) {
21309 this.isStarting = false;
21310 this.endRegexpStack = [];
21311 }
21312 }
21313 visitCharacter(node) {
21314 const char = String.fromCharCode(node.value);
21315 if (!this.multiline && char === '\n') {
21316 this.multiline = true;
21317 }
21318 if (node.quantifier) {
21319 this.isStarting = false;
21320 this.endRegexpStack = [];
21321 }
21322 else {
21323 const escapedChar = escapeRegExp(char);
21324 this.endRegexpStack.push(escapedChar);
21325 if (this.isStarting) {
21326 this.startRegexp += escapedChar;
21327 }
21328 }
21329 }
21330 visitSet(node) {
21331 if (!this.multiline) {
21332 const set = this.regex.substring(node.loc.begin, node.loc.end);
21333 const regex = new RegExp(set);
21334 this.multiline = Boolean('\n'.match(regex));
21335 }
21336 if (node.quantifier) {
21337 this.isStarting = false;
21338 this.endRegexpStack = [];
21339 }
21340 else {
21341 const set = this.regex.substring(node.loc.begin, node.loc.end);
21342 this.endRegexpStack.push(set);
21343 if (this.isStarting) {
21344 this.startRegexp += set;
21345 }
21346 }
21347 }
21348 visitChildren(node) {
21349 if (node.type === 'Group') {
21350 // Ignore children of groups with quantifier (+/*/?)
21351 // These groups are unrelated to start/end tokens of terminals
21352 const group = node;
21353 if (group.quantifier) {
21354 return;
21355 }
21356 }
21357 super.visitChildren(node);
21358 }
21359 }
21360 const visitor = new TerminalRegExpVisitor();
21361 function getTerminalParts(regexp) {
21362 try {
21363 if (typeof regexp !== 'string') {
21364 regexp = regexp.source;
21365 }
21366 regexp = `/${regexp}/`;
21367 const pattern = regexpParser.pattern(regexp);
21368 const parts = [];
21369 for (const alternative of pattern.value.value) {
21370 visitor.reset(regexp);
21371 visitor.visit(alternative);
21372 parts.push({
21373 start: visitor.startRegexp,
21374 end: visitor.endRegex
21375 });
21376 }
21377 return parts;
21378 }
21379 catch (_a) {
21380 return [];
21381 }
21382 }
21383 function isMultilineComment(regexp) {
21384 try {
21385 if (typeof regexp === 'string') {
21386 regexp = new RegExp(regexp);
21387 }
21388 regexp = regexp.toString();
21389 visitor.reset(regexp);
21390 // Parsing the pattern might fail (since it's user code)
21391 visitor.visit(regexpParser.pattern(regexp));
21392 return visitor.multiline;
21393 }
21394 catch (_a) {
21395 return false;
21396 }
21397 }
21398 /**
21399 * A set of all characters that are considered whitespace by the '\s' RegExp character class.
21400 * Taken from [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_expressions/Character_classes).
21401 */
21402 const whitespaceCharacters = ('\f\n\r\t\v\u0020\u00a0\u1680\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007' +
21403 '\u2008\u2009\u200a\u2028\u2029\u202f\u205f\u3000\ufeff').split('');
21404 function isWhitespace(value) {
21405 const regexp = typeof value === 'string' ? new RegExp(value) : value;
21406 return whitespaceCharacters.some((ws) => regexp.test(ws));
21407 }
21408 function escapeRegExp(value) {
21409 return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
21410 }
21411 function getCaseInsensitivePattern(keyword) {
21412 return Array.prototype.map.call(keyword, letter => /\w/.test(letter) ? `[${letter.toLowerCase()}${letter.toUpperCase()}]` : escapeRegExp(letter)).join('');
21413 }
21414 /**
21415 * Determines whether the given input has a partial match with the specified regex.
21416 * @param regex The regex to partially match against
21417 * @param input The input string
21418 * @returns Whether any match exists.
21419 */
21420 function partialMatches(regex, input) {
21421 const partial = partialRegExp(regex);
21422 const match = input.match(partial);
21423 return !!match && match[0].length > 0;
21424 }
21425 /**
21426 * Builds a partial regex from the input regex. A partial regex is able to match incomplete input strings. E.g.
21427 * a partial regex constructed from `/ab/` is able to match the string `a` without needing a following `b` character. However it won't match `b` alone.
21428 * @param regex The input regex to be converted.
21429 * @returns A partial regex constructed from the input regex.
21430 */
21431 function partialRegExp(regex) {
21432 if (typeof regex === 'string') {
21433 regex = new RegExp(regex);
21434 }
21435 const re = regex, source = regex.source;
21436 let i = 0;
21437 function process() {
21438 let result = '', tmp;
21439 function appendRaw(nbChars) {
21440 result += source.substr(i, nbChars);
21441 i += nbChars;
21442 }
21443 function appendOptional(nbChars) {
21444 result += '(?:' + source.substr(i, nbChars) + '|$)';
21445 i += nbChars;
21446 }
21447 while (i < source.length) {
21448 switch (source[i]) {
21449 case '\\':
21450 switch (source[i + 1]) {
21451 case 'c':
21452 appendOptional(3);
21453 break;
21454 case 'x':
21455 appendOptional(4);
21456 break;
21457 case 'u':
21458 if (re.unicode) {
21459 if (source[i + 2] === '{') {
21460 appendOptional(source.indexOf('}', i) - i + 1);
21461 }
21462 else {
21463 appendOptional(6);
21464 }
21465 }
21466 else {
21467 appendOptional(2);
21468 }
21469 break;
21470 case 'p':
21471 case 'P':
21472 if (re.unicode) {
21473 appendOptional(source.indexOf('}', i) - i + 1);
21474 }
21475 else {
21476 appendOptional(2);
21477 }
21478 break;
21479 case 'k':
21480 appendOptional(source.indexOf('>', i) - i + 1);
21481 break;
21482 default:
21483 appendOptional(2);
21484 break;
21485 }
21486 break;
21487 case '[':
21488 tmp = /\[(?:\\.|.)*?\]/g;
21489 tmp.lastIndex = i;
21490 tmp = tmp.exec(source) || [];
21491 appendOptional(tmp[0].length);
21492 break;
21493 case '|':
21494 case '^':
21495 case '$':
21496 case '*':
21497 case '+':
21498 case '?':
21499 appendRaw(1);
21500 break;
21501 case '{':
21502 tmp = /\{\d+,?\d*\}/g;
21503 tmp.lastIndex = i;
21504 tmp = tmp.exec(source);
21505 if (tmp) {
21506 appendRaw(tmp[0].length);
21507 }
21508 else {
21509 appendOptional(1);
21510 }
21511 break;
21512 case '(':
21513 if (source[i + 1] === '?') {
21514 switch (source[i + 2]) {
21515 case ':':
21516 result += '(?:';
21517 i += 3;
21518 result += process() + '|$)';
21519 break;
21520 case '=':
21521 result += '(?=';
21522 i += 3;
21523 result += process() + ')';
21524 break;
21525 case '!':
21526 tmp = i;
21527 i += 3;
21528 process();
21529 result += source.substr(tmp, i - tmp);
21530 break;
21531 case '<':
21532 switch (source[i + 3]) {
21533 case '=':
21534 case '!':
21535 tmp = i;
21536 i += 4;
21537 process();
21538 result += source.substr(tmp, i - tmp);
21539 break;
21540 default:
21541 appendRaw(source.indexOf('>', i) - i + 1);
21542 result += process() + '|$)';
21543 break;
21544 }
21545 break;
21546 }
21547 }
21548 else {
21549 appendRaw(1);
21550 result += process() + '|$)';
21551 }
21552 break;
21553 case ')':
21554 ++i;
21555 return result;
21556 default:
21557 appendOptional(1);
21558 break;
21559 }
21560 }
21561 return result;
21562 }
21563 return new RegExp(process(), regex.flags);
21564 }
21565 //# sourceMappingURL=regexp-utils.js.map
21566
21567 /***/ }),
21568
21569 /***/ 99293:
21570 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
21571
21572 "use strict";
21573 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
21574 /* harmony export */ Cl: () => (/* binding */ EMPTY_STREAM),
21575 /* harmony export */ IH: () => (/* binding */ Reduction),
21576 /* harmony export */ Ry: () => (/* binding */ DONE_RESULT),
21577 /* harmony export */ Vw: () => (/* binding */ stream),
21578 /* harmony export */ i: () => (/* binding */ StreamImpl),
21579 /* harmony export */ i8: () => (/* binding */ TreeStreamImpl)
21580 /* harmony export */ });
21581 /******************************************************************************
21582 * Copyright 2021 TypeFox GmbH
21583 * This program and the accompanying materials are made available under the
21584 * terms of the MIT License, which is available in the project root.
21585 ******************************************************************************/
21586 /**
21587 * The default implementation of `Stream` works with two input functions:
21588 * - The first function creates the initial state of an iteration.
21589 * - The second function gets the current state as argument and returns an `IteratorResult`.
21590 */
21591 class StreamImpl {
21592 constructor(startFn, nextFn) {
21593 this.startFn = startFn;
21594 this.nextFn = nextFn;
21595 }
21596 iterator() {
21597 const iterator = {
21598 state: this.startFn(),
21599 next: () => this.nextFn(iterator.state),
21600 [Symbol.iterator]: () => iterator
21601 };
21602 return iterator;
21603 }
21604 [Symbol.iterator]() {
21605 return this.iterator();
21606 }
21607 isEmpty() {
21608 const iterator = this.iterator();
21609 return Boolean(iterator.next().done);
21610 }
21611 count() {
21612 const iterator = this.iterator();
21613 let count = 0;
21614 let next = iterator.next();
21615 while (!next.done) {
21616 count++;
21617 next = iterator.next();
21618 }
21619 return count;
21620 }
21621 toArray() {
21622 const result = [];
21623 const iterator = this.iterator();
21624 let next;
21625 do {
21626 next = iterator.next();
21627 if (next.value !== undefined) {
21628 result.push(next.value);
21629 }
21630 } while (!next.done);
21631 return result;
21632 }
21633 toSet() {
21634 return new Set(this);
21635 }
21636 toMap(keyFn, valueFn) {
21637 const entryStream = this.map(element => [
21638 keyFn ? keyFn(element) : element,
21639 valueFn ? valueFn(element) : element
21640 ]);
21641 return new Map(entryStream);
21642 }
21643 toString() {
21644 return this.join();
21645 }
21646 concat(other) {
21647 return new StreamImpl(() => ({ first: this.startFn(), firstDone: false, iterator: other[Symbol.iterator]() }), state => {
21648 let result;
21649 if (!state.firstDone) {
21650 do {
21651 result = this.nextFn(state.first);
21652 if (!result.done) {
21653 return result;
21654 }
21655 } while (!result.done);
21656 state.firstDone = true;
21657 }
21658 do {
21659 result = state.iterator.next();
21660 if (!result.done) {
21661 return result;
21662 }
21663 } while (!result.done);
21664 return DONE_RESULT;
21665 });
21666 }
21667 join(separator = ',') {
21668 const iterator = this.iterator();
21669 let value = '';
21670 let result;
21671 let addSeparator = false;
21672 do {
21673 result = iterator.next();
21674 if (!result.done) {
21675 if (addSeparator) {
21676 value += separator;
21677 }
21678 value += toString(result.value);
21679 }
21680 addSeparator = true;
21681 } while (!result.done);
21682 return value;
21683 }
21684 indexOf(searchElement, fromIndex = 0) {
21685 const iterator = this.iterator();
21686 let index = 0;
21687 let next = iterator.next();
21688 while (!next.done) {
21689 if (index >= fromIndex && next.value === searchElement) {
21690 return index;
21691 }
21692 next = iterator.next();
21693 index++;
21694 }
21695 return -1;
21696 }
21697 every(predicate) {
21698 const iterator = this.iterator();
21699 let next = iterator.next();
21700 while (!next.done) {
21701 if (!predicate(next.value)) {
21702 return false;
21703 }
21704 next = iterator.next();
21705 }
21706 return true;
21707 }
21708 some(predicate) {
21709 const iterator = this.iterator();
21710 let next = iterator.next();
21711 while (!next.done) {
21712 if (predicate(next.value)) {
21713 return true;
21714 }
21715 next = iterator.next();
21716 }
21717 return false;
21718 }
21719 forEach(callbackfn) {
21720 const iterator = this.iterator();
21721 let index = 0;
21722 let next = iterator.next();
21723 while (!next.done) {
21724 callbackfn(next.value, index);
21725 next = iterator.next();
21726 index++;
21727 }
21728 }
21729 map(callbackfn) {
21730 return new StreamImpl(this.startFn, (state) => {
21731 const { done, value } = this.nextFn(state);
21732 if (done) {
21733 return DONE_RESULT;
21734 }
21735 else {
21736 return { done: false, value: callbackfn(value) };
21737 }
21738 });
21739 }
21740 filter(predicate) {
21741 return new StreamImpl(this.startFn, state => {
21742 let result;
21743 do {
21744 result = this.nextFn(state);
21745 if (!result.done && predicate(result.value)) {
21746 return result;
21747 }
21748 } while (!result.done);
21749 return DONE_RESULT;
21750 });
21751 }
21752 nonNullable() {
21753 return this.filter(e => e !== undefined && e !== null);
21754 }
21755 reduce(callbackfn, initialValue) {
21756 const iterator = this.iterator();
21757 let previousValue = initialValue;
21758 let next = iterator.next();
21759 while (!next.done) {
21760 if (previousValue === undefined) {
21761 previousValue = next.value;
21762 }
21763 else {
21764 previousValue = callbackfn(previousValue, next.value);
21765 }
21766 next = iterator.next();
21767 }
21768 return previousValue;
21769 }
21770 reduceRight(callbackfn, initialValue) {
21771 return this.recursiveReduce(this.iterator(), callbackfn, initialValue);
21772 }
21773 recursiveReduce(iterator, callbackfn, initialValue) {
21774 const next = iterator.next();
21775 if (next.done) {
21776 return initialValue;
21777 }
21778 const previousValue = this.recursiveReduce(iterator, callbackfn, initialValue);
21779 if (previousValue === undefined) {
21780 return next.value;
21781 }
21782 return callbackfn(previousValue, next.value);
21783 }
21784 find(predicate) {
21785 const iterator = this.iterator();
21786 let next = iterator.next();
21787 while (!next.done) {
21788 if (predicate(next.value)) {
21789 return next.value;
21790 }
21791 next = iterator.next();
21792 }
21793 return undefined;
21794 }
21795 findIndex(predicate) {
21796 const iterator = this.iterator();
21797 let index = 0;
21798 let next = iterator.next();
21799 while (!next.done) {
21800 if (predicate(next.value)) {
21801 return index;
21802 }
21803 next = iterator.next();
21804 index++;
21805 }
21806 return -1;
21807 }
21808 includes(searchElement) {
21809 const iterator = this.iterator();
21810 let next = iterator.next();
21811 while (!next.done) {
21812 if (next.value === searchElement) {
21813 return true;
21814 }
21815 next = iterator.next();
21816 }
21817 return false;
21818 }
21819 flatMap(callbackfn) {
21820 return new StreamImpl(() => ({ this: this.startFn() }), (state) => {
21821 do {
21822 if (state.iterator) {
21823 const next = state.iterator.next();
21824 if (next.done) {
21825 state.iterator = undefined;
21826 }
21827 else {
21828 return next;
21829 }
21830 }
21831 const { done, value } = this.nextFn(state.this);
21832 if (!done) {
21833 const mapped = callbackfn(value);
21834 if (isIterable(mapped)) {
21835 state.iterator = mapped[Symbol.iterator]();
21836 }
21837 else {
21838 return { done: false, value: mapped };
21839 }
21840 }
21841 } while (state.iterator);
21842 return DONE_RESULT;
21843 });
21844 }
21845 flat(depth) {
21846 if (depth === undefined) {
21847 depth = 1;
21848 }
21849 if (depth <= 0) {
21850 return this;
21851 }
21852 const stream = depth > 1 ? this.flat(depth - 1) : this;
21853 return new StreamImpl(() => ({ this: stream.startFn() }), (state) => {
21854 do {
21855 if (state.iterator) {
21856 const next = state.iterator.next();
21857 if (next.done) {
21858 state.iterator = undefined;
21859 }
21860 else {
21861 return next;
21862 }
21863 }
21864 const { done, value } = stream.nextFn(state.this);
21865 if (!done) {
21866 if (isIterable(value)) {
21867 state.iterator = value[Symbol.iterator]();
21868 }
21869 else {
21870 return { done: false, value: value };
21871 }
21872 }
21873 } while (state.iterator);
21874 return DONE_RESULT;
21875 });
21876 }
21877 head() {
21878 const iterator = this.iterator();
21879 const result = iterator.next();
21880 if (result.done) {
21881 return undefined;
21882 }
21883 return result.value;
21884 }
21885 tail(skipCount = 1) {
21886 return new StreamImpl(() => {
21887 const state = this.startFn();
21888 for (let i = 0; i < skipCount; i++) {
21889 const next = this.nextFn(state);
21890 if (next.done) {
21891 return state;
21892 }
21893 }
21894 return state;
21895 }, this.nextFn);
21896 }
21897 limit(maxSize) {
21898 return new StreamImpl(() => ({ size: 0, state: this.startFn() }), state => {
21899 state.size++;
21900 if (state.size > maxSize) {
21901 return DONE_RESULT;
21902 }
21903 return this.nextFn(state.state);
21904 });
21905 }
21906 distinct(by) {
21907 return new StreamImpl(() => ({ set: new Set(), internalState: this.startFn() }), state => {
21908 let result;
21909 do {
21910 result = this.nextFn(state.internalState);
21911 if (!result.done) {
21912 const value = by ? by(result.value) : result.value;
21913 if (!state.set.has(value)) {
21914 state.set.add(value);
21915 return result;
21916 }
21917 }
21918 } while (!result.done);
21919 return DONE_RESULT;
21920 });
21921 }
21922 exclude(other, key) {
21923 const otherKeySet = new Set();
21924 for (const item of other) {
21925 const value = key ? key(item) : item;
21926 otherKeySet.add(value);
21927 }
21928 return this.filter(e => {
21929 const ownKey = key ? key(e) : e;
21930 return !otherKeySet.has(ownKey);
21931 });
21932 }
21933 }
21934 function toString(item) {
21935 if (typeof item === 'string') {
21936 return item;
21937 }
21938 if (typeof item === 'undefined') {
21939 return 'undefined';
21940 }
21941 // eslint-disable-next-line @typescript-eslint/no-explicit-any
21942 if (typeof item.toString === 'function') {
21943 // eslint-disable-next-line @typescript-eslint/no-explicit-any
21944 return item.toString();
21945 }
21946 return Object.prototype.toString.call(item);
21947 }
21948 function isIterable(obj) {
21949 return !!obj && typeof obj[Symbol.iterator] === 'function';
21950 }
21951 /**
21952 * An empty stream of any type.
21953 */
21954 // eslint-disable-next-line @typescript-eslint/no-explicit-any
21955 const EMPTY_STREAM = new StreamImpl(() => undefined, () => DONE_RESULT);
21956 /**
21957 * Use this `IteratorResult` when implementing a `StreamImpl` to indicate that there are no more elements in the stream.
21958 */
21959 const DONE_RESULT = Object.freeze({ done: true, value: undefined });
21960 /**
21961 * Create a stream from one or more iterables or array-likes.
21962 */
21963 function stream(...collections) {
21964 if (collections.length === 1) {
21965 const collection = collections[0];
21966 if (collection instanceof StreamImpl) {
21967 return collection;
21968 }
21969 if (isIterable(collection)) {
21970 return new StreamImpl(() => collection[Symbol.iterator](), (iterator) => iterator.next());
21971 }
21972 if (typeof collection.length === 'number') {
21973 return new StreamImpl(() => ({ index: 0 }), (state) => {
21974 if (state.index < collection.length) {
21975 return { done: false, value: collection[state.index++] };
21976 }
21977 else {
21978 return DONE_RESULT;
21979 }
21980 });
21981 }
21982 }
21983 if (collections.length > 1) {
21984 return new StreamImpl(() => ({ collIndex: 0, arrIndex: 0 }), (state) => {
21985 do {
21986 if (state.iterator) {
21987 const next = state.iterator.next();
21988 if (!next.done) {
21989 return next;
21990 }
21991 state.iterator = undefined;
21992 }
21993 if (state.array) {
21994 if (state.arrIndex < state.array.length) {
21995 return { done: false, value: state.array[state.arrIndex++] };
21996 }
21997 state.array = undefined;
21998 state.arrIndex = 0;
21999 }
22000 if (state.collIndex < collections.length) {
22001 const collection = collections[state.collIndex++];
22002 if (isIterable(collection)) {
22003 state.iterator = collection[Symbol.iterator]();
22004 }
22005 else if (collection && typeof collection.length === 'number') {
22006 state.array = collection;
22007 }
22008 }
22009 } while (state.iterator || state.array || state.collIndex < collections.length);
22010 return DONE_RESULT;
22011 });
22012 }
22013 return EMPTY_STREAM;
22014 }
22015 /**
22016 * The default implementation of `TreeStream` takes a root element and a function that computes the
22017 * children of its argument. Whether the root node included in the stream is controlled with the
22018 * `includeRoot` option, which defaults to `false`.
22019 */
22020 class TreeStreamImpl extends StreamImpl {
22021 constructor(root, children, options) {
22022 super(() => ({
22023 iterators: (options === null || options === void 0 ? void 0 : options.includeRoot) ? [[root][Symbol.iterator]()] : [children(root)[Symbol.iterator]()],
22024 pruned: false
22025 }), state => {
22026 if (state.pruned) {
22027 state.iterators.pop();
22028 state.pruned = false;
22029 }
22030 while (state.iterators.length > 0) {
22031 const iterator = state.iterators[state.iterators.length - 1];
22032 const next = iterator.next();
22033 if (next.done) {
22034 state.iterators.pop();
22035 }
22036 else {
22037 state.iterators.push(children(next.value)[Symbol.iterator]());
22038 return next;
22039 }
22040 }
22041 return DONE_RESULT;
22042 });
22043 }
22044 iterator() {
22045 const iterator = {
22046 state: this.startFn(),
22047 next: () => this.nextFn(iterator.state),
22048 prune: () => {
22049 iterator.state.pruned = true;
22050 },
22051 [Symbol.iterator]: () => iterator
22052 };
22053 return iterator;
22054 }
22055 }
22056 /**
22057 * A set of utility functions that reduce a stream to a single value.
22058 */
22059 var Reduction;
22060 (function (Reduction) {
22061 /**
22062 * Compute the sum of a number stream.
22063 */
22064 function sum(stream) {
22065 return stream.reduce((a, b) => a + b, 0);
22066 }
22067 Reduction.sum = sum;
22068 /**
22069 * Compute the product of a number stream.
22070 */
22071 function product(stream) {
22072 return stream.reduce((a, b) => a * b, 0);
22073 }
22074 Reduction.product = product;
22075 /**
22076 * Compute the minimum of a number stream. Returns `undefined` if the stream is empty.
22077 */
22078 function min(stream) {
22079 return stream.reduce((a, b) => Math.min(a, b));
22080 }
22081 Reduction.min = min;
22082 /**
22083 * Compute the maximum of a number stream. Returns `undefined` if the stream is empty.
22084 */
22085 function max(stream) {
22086 return stream.reduce((a, b) => Math.max(a, b));
22087 }
22088 Reduction.max = max;
22089 })(Reduction || (Reduction = {}));
22090 //# sourceMappingURL=stream.js.map
22091
22092 /***/ }),
22093
22094 /***/ 44014:
22095 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
22096
22097 "use strict";
22098 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
22099 /* harmony export */ u: () => (/* binding */ EmptyFileSystem)
22100 /* harmony export */ });
22101 /* unused harmony export EmptyFileSystemProvider */
22102 /******************************************************************************
22103 * Copyright 2022 TypeFox GmbH
22104 * This program and the accompanying materials are made available under the
22105 * terms of the MIT License, which is available in the project root.
22106 ******************************************************************************/
22107 class EmptyFileSystemProvider {
22108 readFile() {
22109 throw new Error('No file system is available.');
22110 }
22111 async readDirectory() {
22112 return [];
22113 }
22114 }
22115 const EmptyFileSystem = {
22116 fileSystemProvider: () => new EmptyFileSystemProvider()
22117 };
22118 //# sourceMappingURL=file-system-provider.js.map
22119
22120 /***/ }),
22121
22122 /***/ 41589:
22123 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
22124
22125 "use strict";
22126 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
22127 /* harmony export */ Z: () => (__WEBPACK_DEFAULT_EXPORT__)
22128 /* harmony export */ });
22129 /* harmony import */ var _isSymbol_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(59660);
22130
22131
22132 /**
22133 * The base implementation of methods like `_.max` and `_.min` which accepts a
22134 * `comparator` to determine the extremum value.
22135 *
22136 * @private
22137 * @param {Array} array The array to iterate over.
22138 * @param {Function} iteratee The iteratee invoked per iteration.
22139 * @param {Function} comparator The comparator used to compare values.
22140 * @returns {*} Returns the extremum value.
22141 */
22142 function baseExtremum(array, iteratee, comparator) {
22143 var index = -1,
22144 length = array.length;
22145
22146 while (++index < length) {
22147 var value = array[index],
22148 current = iteratee(value);
22149
22150 if (current != null && (computed === undefined
22151 ? (current === current && !(0,_isSymbol_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z)(current))
22152 : comparator(current, computed)
22153 )) {
22154 var computed = current,
22155 result = value;
22156 }
22157 }
22158 return result;
22159 }
22160
22161 /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (baseExtremum);
22162
22163
22164 /***/ }),
22165
22166 /***/ 79520:
22167 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
22168
22169 "use strict";
22170 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
22171 /* harmony export */ Z: () => (__WEBPACK_DEFAULT_EXPORT__)
22172 /* harmony export */ });
22173 /**
22174 * The base implementation of `_.lt` which doesn't coerce arguments.
22175 *
22176 * @private
22177 * @param {*} value The value to compare.
22178 * @param {*} other The other value to compare.
22179 * @returns {boolean} Returns `true` if `value` is less than `other`,
22180 * else `false`.
22181 */
22182 function baseLt(value, other) {
22183 return value < other;
22184 }
22185
22186 /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (baseLt);
22187
22188
22189 /***/ }),
22190
22191 /***/ 15521:
22192 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
22193
22194 "use strict";
22195 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
22196 /* harmony export */ Z: () => (__WEBPACK_DEFAULT_EXPORT__)
22197 /* harmony export */ });
22198 /* harmony import */ var _baseEach_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(77201);
22199 /* harmony import */ var _isArrayLike_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(69959);
22200
22201
22202
22203 /**
22204 * The base implementation of `_.map` without support for iteratee shorthands.
22205 *
22206 * @private
22207 * @param {Array|Object} collection The collection to iterate over.
22208 * @param {Function} iteratee The function invoked per iteration.
22209 * @returns {Array} Returns the new mapped array.
22210 */
22211 function baseMap(collection, iteratee) {
22212 var index = -1,
22213 result = (0,_isArrayLike_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z)(collection) ? Array(collection.length) : [];
22214
22215 (0,_baseEach_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z)(collection, function(value, key, collection) {
22216 result[++index] = iteratee(value, key, collection);
22217 });
22218 return result;
22219 }
22220
22221 /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (baseMap);
22222
22223
22224 /***/ }),
22225
22226 /***/ 73338:
22227 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
22228
22229 "use strict";
22230
22231 // EXPORTS
22232 __webpack_require__.d(__webpack_exports__, {
22233 Z: () => (/* binding */ _basePickBy)
22234 });
22235
22236 // EXTERNAL MODULE: ../node_modules/lodash-es/_baseGet.js
22237 var _baseGet = __webpack_require__(78402);
22238 // EXTERNAL MODULE: ../node_modules/lodash-es/_assignValue.js
22239 var _assignValue = __webpack_require__(15561);
22240 // EXTERNAL MODULE: ../node_modules/lodash-es/_castPath.js + 2 modules
22241 var _castPath = __webpack_require__(94022);
22242 // EXTERNAL MODULE: ../node_modules/lodash-es/_isIndex.js
22243 var _isIndex = __webpack_require__(8616);
22244 // EXTERNAL MODULE: ../node_modules/lodash-es/isObject.js
22245 var isObject = __webpack_require__(60417);
22246 // EXTERNAL MODULE: ../node_modules/lodash-es/_toKey.js
22247 var _toKey = __webpack_require__(13550);
22248 ;// CONCATENATED MODULE: ../node_modules/lodash-es/_baseSet.js
22249
22250
22251
22252
22253
22254
22255 /**
22256 * The base implementation of `_.set`.
22257 *
22258 * @private
22259 * @param {Object} object The object to modify.
22260 * @param {Array|string} path The path of the property to set.
22261 * @param {*} value The value to set.
22262 * @param {Function} [customizer] The function to customize path creation.
22263 * @returns {Object} Returns `object`.
22264 */
22265 function baseSet(object, path, value, customizer) {
22266 if (!(0,isObject/* default */.Z)(object)) {
22267 return object;
22268 }
22269 path = (0,_castPath/* default */.Z)(path, object);
22270
22271 var index = -1,
22272 length = path.length,
22273 lastIndex = length - 1,
22274 nested = object;
22275
22276 while (nested != null && ++index < length) {
22277 var key = (0,_toKey/* default */.Z)(path[index]),
22278 newValue = value;
22279
22280 if (key === '__proto__' || key === 'constructor' || key === 'prototype') {
22281 return object;
22282 }
22283
22284 if (index != lastIndex) {
22285 var objValue = nested[key];
22286 newValue = customizer ? customizer(objValue, key, nested) : undefined;
22287 if (newValue === undefined) {
22288 newValue = (0,isObject/* default */.Z)(objValue)
22289 ? objValue
22290 : ((0,_isIndex/* default */.Z)(path[index + 1]) ? [] : {});
22291 }
22292 }
22293 (0,_assignValue/* default */.Z)(nested, key, newValue);
22294 nested = nested[key];
22295 }
22296 return object;
22297 }
22298
22299 /* harmony default export */ const _baseSet = (baseSet);
22300
22301 ;// CONCATENATED MODULE: ../node_modules/lodash-es/_basePickBy.js
22302
22303
22304
22305
22306 /**
22307 * The base implementation of `_.pickBy` without support for iteratee shorthands.
22308 *
22309 * @private
22310 * @param {Object} object The source object.
22311 * @param {string[]} paths The property paths to pick.
22312 * @param {Function} predicate The function invoked per property.
22313 * @returns {Object} Returns the new object.
22314 */
22315 function basePickBy(object, paths, predicate) {
22316 var index = -1,
22317 length = paths.length,
22318 result = {};
22319
22320 while (++index < length) {
22321 var path = paths[index],
22322 value = (0,_baseGet/* default */.Z)(object, path);
22323
22324 if (predicate(value, path)) {
22325 _baseSet(result, (0,_castPath/* default */.Z)(path, object), value);
22326 }
22327 }
22328 return result;
22329 }
22330
22331 /* harmony default export */ const _basePickBy = (basePickBy);
22332
22333
22334 /***/ }),
22335
22336 /***/ 20190:
22337 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
22338
22339 "use strict";
22340 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
22341 /* harmony export */ Z: () => (__WEBPACK_DEFAULT_EXPORT__)
22342 /* harmony export */ });
22343 /* harmony import */ var _baseClone_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(38193);
22344
22345
22346 /** Used to compose bitmasks for cloning. */
22347 var CLONE_SYMBOLS_FLAG = 4;
22348
22349 /**
22350 * Creates a shallow clone of `value`.
22351 *
22352 * **Note:** This method is loosely based on the
22353 * [structured clone algorithm](https://mdn.io/Structured_clone_algorithm)
22354 * and supports cloning arrays, array buffers, booleans, date objects, maps,
22355 * numbers, `Object` objects, regexes, sets, strings, symbols, and typed
22356 * arrays. The own enumerable properties of `arguments` objects are cloned
22357 * as plain objects. An empty object is returned for uncloneable values such
22358 * as error objects, functions, DOM nodes, and WeakMaps.
22359 *
22360 * @static
22361 * @memberOf _
22362 * @since 0.1.0
22363 * @category Lang
22364 * @param {*} value The value to clone.
22365 * @returns {*} Returns the cloned value.
22366 * @see _.cloneDeep
22367 * @example
22368 *
22369 * var objects = [{ 'a': 1 }, { 'b': 2 }];
22370 *
22371 * var shallow = _.clone(objects);
22372 * console.log(shallow[0] === objects[0]);
22373 * // => true
22374 */
22375 function clone(value) {
22376 return (0,_baseClone_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z)(value, CLONE_SYMBOLS_FLAG);
22377 }
22378
22379 /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (clone);
22380
22381
22382 /***/ }),
22383
22384 /***/ 65479:
22385 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
22386
22387 "use strict";
22388 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
22389 /* harmony export */ Z: () => (__WEBPACK_DEFAULT_EXPORT__)
22390 /* harmony export */ });
22391 /* harmony import */ var _baseRest_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(99719);
22392 /* harmony import */ var _eq_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(35050);
22393 /* harmony import */ var _isIterateeCall_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(47952);
22394 /* harmony import */ var _keysIn_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(48441);
22395
22396
22397
22398
22399
22400 /** Used for built-in method references. */
22401 var objectProto = Object.prototype;
22402
22403 /** Used to check objects for own properties. */
22404 var hasOwnProperty = objectProto.hasOwnProperty;
22405
22406 /**
22407 * Assigns own and inherited enumerable string keyed properties of source
22408 * objects to the destination object for all destination properties that
22409 * resolve to `undefined`. Source objects are applied from left to right.
22410 * Once a property is set, additional values of the same property are ignored.
22411 *
22412 * **Note:** This method mutates `object`.
22413 *
22414 * @static
22415 * @since 0.1.0
22416 * @memberOf _
22417 * @category Object
22418 * @param {Object} object The destination object.
22419 * @param {...Object} [sources] The source objects.
22420 * @returns {Object} Returns `object`.
22421 * @see _.defaultsDeep
22422 * @example
22423 *
22424 * _.defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });
22425 * // => { 'a': 1, 'b': 2 }
22426 */
22427 var defaults = (0,_baseRest_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z)(function(object, sources) {
22428 object = Object(object);
22429
22430 var index = -1;
22431 var length = sources.length;
22432 var guard = length > 2 ? sources[2] : undefined;
22433
22434 if (guard && (0,_isIterateeCall_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z)(sources[0], sources[1], guard)) {
22435 length = 1;
22436 }
22437
22438 while (++index < length) {
22439 var source = sources[index];
22440 var props = (0,_keysIn_js__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .Z)(source);
22441 var propsIndex = -1;
22442 var propsLength = props.length;
22443
22444 while (++propsIndex < propsLength) {
22445 var key = props[propsIndex];
22446 var value = object[key];
22447
22448 if (value === undefined ||
22449 ((0,_eq_js__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .Z)(value, objectProto[key]) && !hasOwnProperty.call(object, key))) {
22450 object[key] = source[key];
22451 }
22452 }
22453 }
22454
22455 return object;
22456 });
22457
22458 /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (defaults);
22459
22460
22461 /***/ }),
22462
22463 /***/ 90970:
22464 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
22465
22466 "use strict";
22467
22468 // EXPORTS
22469 __webpack_require__.d(__webpack_exports__, {
22470 Z: () => (/* binding */ lodash_es_find)
22471 });
22472
22473 // EXTERNAL MODULE: ../node_modules/lodash-es/_baseIteratee.js + 15 modules
22474 var _baseIteratee = __webpack_require__(86494);
22475 // EXTERNAL MODULE: ../node_modules/lodash-es/isArrayLike.js
22476 var isArrayLike = __webpack_require__(69959);
22477 // EXTERNAL MODULE: ../node_modules/lodash-es/keys.js
22478 var keys = __webpack_require__(11723);
22479 ;// CONCATENATED MODULE: ../node_modules/lodash-es/_createFind.js
22480
22481
22482
22483
22484 /**
22485 * Creates a `_.find` or `_.findLast` function.
22486 *
22487 * @private
22488 * @param {Function} findIndexFunc The function to find the collection index.
22489 * @returns {Function} Returns the new find function.
22490 */
22491 function createFind(findIndexFunc) {
22492 return function(collection, predicate, fromIndex) {
22493 var iterable = Object(collection);
22494 if (!(0,isArrayLike/* default */.Z)(collection)) {
22495 var iteratee = (0,_baseIteratee/* default */.Z)(predicate, 3);
22496 collection = (0,keys/* default */.Z)(collection);
22497 predicate = function(key) { return iteratee(iterable[key], key, iterable); };
22498 }
22499 var index = findIndexFunc(collection, predicate, fromIndex);
22500 return index > -1 ? iterable[iteratee ? collection[index] : index] : undefined;
22501 };
22502 }
22503
22504 /* harmony default export */ const _createFind = (createFind);
22505
22506 // EXTERNAL MODULE: ../node_modules/lodash-es/_baseFindIndex.js
22507 var _baseFindIndex = __webpack_require__(9872);
22508 // EXTERNAL MODULE: ../node_modules/lodash-es/toInteger.js
22509 var toInteger = __webpack_require__(98670);
22510 ;// CONCATENATED MODULE: ../node_modules/lodash-es/findIndex.js
22511
22512
22513
22514
22515 /* Built-in method references for those with the same name as other `lodash` methods. */
22516 var nativeMax = Math.max;
22517
22518 /**
22519 * This method is like `_.find` except that it returns the index of the first
22520 * element `predicate` returns truthy for instead of the element itself.
22521 *
22522 * @static
22523 * @memberOf _
22524 * @since 1.1.0
22525 * @category Array
22526 * @param {Array} array The array to inspect.
22527 * @param {Function} [predicate=_.identity] The function invoked per iteration.
22528 * @param {number} [fromIndex=0] The index to search from.
22529 * @returns {number} Returns the index of the found element, else `-1`.
22530 * @example
22531 *
22532 * var users = [
22533 * { 'user': 'barney', 'active': false },
22534 * { 'user': 'fred', 'active': false },
22535 * { 'user': 'pebbles', 'active': true }
22536 * ];
22537 *
22538 * _.findIndex(users, function(o) { return o.user == 'barney'; });
22539 * // => 0
22540 *
22541 * // The `_.matches` iteratee shorthand.
22542 * _.findIndex(users, { 'user': 'fred', 'active': false });
22543 * // => 1
22544 *
22545 * // The `_.matchesProperty` iteratee shorthand.
22546 * _.findIndex(users, ['active', false]);
22547 * // => 0
22548 *
22549 * // The `_.property` iteratee shorthand.
22550 * _.findIndex(users, 'active');
22551 * // => 2
22552 */
22553 function findIndex(array, predicate, fromIndex) {
22554 var length = array == null ? 0 : array.length;
22555 if (!length) {
22556 return -1;
22557 }
22558 var index = fromIndex == null ? 0 : (0,toInteger/* default */.Z)(fromIndex);
22559 if (index < 0) {
22560 index = nativeMax(length + index, 0);
22561 }
22562 return (0,_baseFindIndex/* default */.Z)(array, (0,_baseIteratee/* default */.Z)(predicate, 3), index);
22563 }
22564
22565 /* harmony default export */ const lodash_es_findIndex = (findIndex);
22566
22567 ;// CONCATENATED MODULE: ../node_modules/lodash-es/find.js
22568
22569
22570
22571 /**
22572 * Iterates over elements of `collection`, returning the first element
22573 * `predicate` returns truthy for. The predicate is invoked with three
22574 * arguments: (value, index|key, collection).
22575 *
22576 * @static
22577 * @memberOf _
22578 * @since 0.1.0
22579 * @category Collection
22580 * @param {Array|Object} collection The collection to inspect.
22581 * @param {Function} [predicate=_.identity] The function invoked per iteration.
22582 * @param {number} [fromIndex=0] The index to search from.
22583 * @returns {*} Returns the matched element, else `undefined`.
22584 * @example
22585 *
22586 * var users = [
22587 * { 'user': 'barney', 'age': 36, 'active': true },
22588 * { 'user': 'fred', 'age': 40, 'active': false },
22589 * { 'user': 'pebbles', 'age': 1, 'active': true }
22590 * ];
22591 *
22592 * _.find(users, function(o) { return o.age < 40; });
22593 * // => object for 'barney'
22594 *
22595 * // The `_.matches` iteratee shorthand.
22596 * _.find(users, { 'age': 1, 'active': true });
22597 * // => object for 'pebbles'
22598 *
22599 * // The `_.matchesProperty` iteratee shorthand.
22600 * _.find(users, ['active', false]);
22601 * // => object for 'fred'
22602 *
22603 * // The `_.property` iteratee shorthand.
22604 * _.find(users, 'active');
22605 * // => object for 'barney'
22606 */
22607 var find = _createFind(lodash_es_findIndex);
22608
22609 /* harmony default export */ const lodash_es_find = (find);
22610
22611
22612 /***/ }),
22613
22614 /***/ 34134:
22615 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
22616
22617 "use strict";
22618 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
22619 /* harmony export */ Z: () => (__WEBPACK_DEFAULT_EXPORT__)
22620 /* harmony export */ });
22621 /* harmony import */ var _baseFlatten_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(65029);
22622 /* harmony import */ var _map_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(12930);
22623
22624
22625
22626 /**
22627 * Creates a flattened array of values by running each element in `collection`
22628 * thru `iteratee` and flattening the mapped results. The iteratee is invoked
22629 * with three arguments: (value, index|key, collection).
22630 *
22631 * @static
22632 * @memberOf _
22633 * @since 4.0.0
22634 * @category Collection
22635 * @param {Array|Object} collection The collection to iterate over.
22636 * @param {Function} [iteratee=_.identity] The function invoked per iteration.
22637 * @returns {Array} Returns the new flattened array.
22638 * @example
22639 *
22640 * function duplicate(n) {
22641 * return [n, n];
22642 * }
22643 *
22644 * _.flatMap([1, 2], duplicate);
22645 * // => [1, 1, 2, 2]
22646 */
22647 function flatMap(collection, iteratee) {
22648 return (0,_baseFlatten_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z)((0,_map_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z)(collection, iteratee), 1);
22649 }
22650
22651 /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (flatMap);
22652
22653
22654 /***/ }),
22655
22656 /***/ 28099:
22657 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
22658
22659 "use strict";
22660 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
22661 /* harmony export */ Z: () => (__WEBPACK_DEFAULT_EXPORT__)
22662 /* harmony export */ });
22663 /* harmony import */ var _baseFlatten_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(65029);
22664
22665
22666 /**
22667 * Flattens `array` a single level deep.
22668 *
22669 * @static
22670 * @memberOf _
22671 * @since 0.1.0
22672 * @category Array
22673 * @param {Array} array The array to flatten.
22674 * @returns {Array} Returns the new flattened array.
22675 * @example
22676 *
22677 * _.flatten([1, [2, [3, [4]], 5]]);
22678 * // => [1, 2, [3, [4]], 5]
22679 */
22680 function flatten(array) {
22681 var length = array == null ? 0 : array.length;
22682 return length ? (0,_baseFlatten_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z)(array, 1) : [];
22683 }
22684
22685 /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (flatten);
22686
22687
22688 /***/ }),
22689
22690 /***/ 36004:
22691 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
22692
22693 "use strict";
22694
22695 // EXPORTS
22696 __webpack_require__.d(__webpack_exports__, {
22697 Z: () => (/* binding */ lodash_es_has)
22698 });
22699
22700 ;// CONCATENATED MODULE: ../node_modules/lodash-es/_baseHas.js
22701 /** Used for built-in method references. */
22702 var objectProto = Object.prototype;
22703
22704 /** Used to check objects for own properties. */
22705 var _baseHas_hasOwnProperty = objectProto.hasOwnProperty;
22706
22707 /**
22708 * The base implementation of `_.has` without support for deep paths.
22709 *
22710 * @private
22711 * @param {Object} [object] The object to query.
22712 * @param {Array|string} key The key to check.
22713 * @returns {boolean} Returns `true` if `key` exists, else `false`.
22714 */
22715 function baseHas(object, key) {
22716 return object != null && _baseHas_hasOwnProperty.call(object, key);
22717 }
22718
22719 /* harmony default export */ const _baseHas = (baseHas);
22720
22721 // EXTERNAL MODULE: ../node_modules/lodash-es/_hasPath.js
22722 var _hasPath = __webpack_require__(18625);
22723 ;// CONCATENATED MODULE: ../node_modules/lodash-es/has.js
22724
22725
22726
22727 /**
22728 * Checks if `path` is a direct property of `object`.
22729 *
22730 * @static
22731 * @since 0.1.0
22732 * @memberOf _
22733 * @category Object
22734 * @param {Object} object The object to query.
22735 * @param {Array|string} path The path to check.
22736 * @returns {boolean} Returns `true` if `path` exists, else `false`.
22737 * @example
22738 *
22739 * var object = { 'a': { 'b': 2 } };
22740 * var other = _.create({ 'a': _.create({ 'b': 2 }) });
22741 *
22742 * _.has(object, 'a');
22743 * // => true
22744 *
22745 * _.has(object, 'a.b');
22746 * // => true
22747 *
22748 * _.has(object, ['a', 'b']);
22749 * // => true
22750 *
22751 * _.has(other, 'a');
22752 * // => false
22753 */
22754 function has(object, path) {
22755 return object != null && (0,_hasPath/* default */.Z)(object, path, _baseHas);
22756 }
22757
22758 /* harmony default export */ const lodash_es_has = (has);
22759
22760
22761 /***/ }),
22762
22763 /***/ 75732:
22764 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
22765
22766 "use strict";
22767 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
22768 /* harmony export */ Z: () => (__WEBPACK_DEFAULT_EXPORT__)
22769 /* harmony export */ });
22770 /* harmony import */ var _baseGetTag_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(77070);
22771 /* harmony import */ var _isArray_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(64058);
22772 /* harmony import */ var _isObjectLike_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(9615);
22773
22774
22775
22776
22777 /** `Object#toString` result references. */
22778 var stringTag = '[object String]';
22779
22780 /**
22781 * Checks if `value` is classified as a `String` primitive or object.
22782 *
22783 * @static
22784 * @since 0.1.0
22785 * @memberOf _
22786 * @category Lang
22787 * @param {*} value The value to check.
22788 * @returns {boolean} Returns `true` if `value` is a string, else `false`.
22789 * @example
22790 *
22791 * _.isString('abc');
22792 * // => true
22793 *
22794 * _.isString(1);
22795 * // => false
22796 */
22797 function isString(value) {
22798 return typeof value == 'string' ||
22799 (!(0,_isArray_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z)(value) && (0,_isObjectLike_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z)(value) && (0,_baseGetTag_js__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .Z)(value) == stringTag);
22800 }
22801
22802 /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (isString);
22803
22804
22805 /***/ }),
22806
22807 /***/ 36411:
22808 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
22809
22810 "use strict";
22811 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
22812 /* harmony export */ Z: () => (__WEBPACK_DEFAULT_EXPORT__)
22813 /* harmony export */ });
22814 /**
22815 * Gets the last element of `array`.
22816 *
22817 * @static
22818 * @memberOf _
22819 * @since 0.1.0
22820 * @category Array
22821 * @param {Array} array The array to query.
22822 * @returns {*} Returns the last element of `array`.
22823 * @example
22824 *
22825 * _.last([1, 2, 3]);
22826 * // => 3
22827 */
22828 function last(array) {
22829 var length = array == null ? 0 : array.length;
22830 return length ? array[length - 1] : undefined;
22831 }
22832
22833 /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (last);
22834
22835
22836 /***/ }),
22837
22838 /***/ 12930:
22839 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
22840
22841 "use strict";
22842 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
22843 /* harmony export */ Z: () => (__WEBPACK_DEFAULT_EXPORT__)
22844 /* harmony export */ });
22845 /* harmony import */ var _arrayMap_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(33043);
22846 /* harmony import */ var _baseIteratee_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(86494);
22847 /* harmony import */ var _baseMap_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(15521);
22848 /* harmony import */ var _isArray_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(64058);
22849
22850
22851
22852
22853
22854 /**
22855 * Creates an array of values by running each element in `collection` thru
22856 * `iteratee`. The iteratee is invoked with three arguments:
22857 * (value, index|key, collection).
22858 *
22859 * Many lodash methods are guarded to work as iteratees for methods like
22860 * `_.every`, `_.filter`, `_.map`, `_.mapValues`, `_.reject`, and `_.some`.
22861 *
22862 * The guarded methods are:
22863 * `ary`, `chunk`, `curry`, `curryRight`, `drop`, `dropRight`, `every`,
22864 * `fill`, `invert`, `parseInt`, `random`, `range`, `rangeRight`, `repeat`,
22865 * `sampleSize`, `slice`, `some`, `sortBy`, `split`, `take`, `takeRight`,
22866 * `template`, `trim`, `trimEnd`, `trimStart`, and `words`
22867 *
22868 * @static
22869 * @memberOf _
22870 * @since 0.1.0
22871 * @category Collection
22872 * @param {Array|Object} collection The collection to iterate over.
22873 * @param {Function} [iteratee=_.identity] The function invoked per iteration.
22874 * @returns {Array} Returns the new mapped array.
22875 * @example
22876 *
22877 * function square(n) {
22878 * return n * n;
22879 * }
22880 *
22881 * _.map([4, 8], square);
22882 * // => [16, 64]
22883 *
22884 * _.map({ 'a': 4, 'b': 8 }, square);
22885 * // => [16, 64] (iteration order is not guaranteed)
22886 *
22887 * var users = [
22888 * { 'user': 'barney' },
22889 * { 'user': 'fred' }
22890 * ];
22891 *
22892 * // The `_.property` iteratee shorthand.
22893 * _.map(users, 'user');
22894 * // => ['barney', 'fred']
22895 */
22896 function map(collection, iteratee) {
22897 var func = (0,_isArray_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z)(collection) ? _arrayMap_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z : _baseMap_js__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .Z;
22898 return func(collection, (0,_baseIteratee_js__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .Z)(iteratee, 3));
22899 }
22900
22901 /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (map);
22902
22903
22904 /***/ }),
22905
22906 /***/ 18519:
22907 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
22908
22909 "use strict";
22910 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
22911 /* harmony export */ Z: () => (__WEBPACK_DEFAULT_EXPORT__)
22912 /* harmony export */ });
22913 /* harmony import */ var _baseExtremum_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(41589);
22914 /* harmony import */ var _baseLt_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(79520);
22915 /* harmony import */ var _identity_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(64056);
22916
22917
22918
22919
22920 /**
22921 * Computes the minimum value of `array`. If `array` is empty or falsey,
22922 * `undefined` is returned.
22923 *
22924 * @static
22925 * @since 0.1.0
22926 * @memberOf _
22927 * @category Math
22928 * @param {Array} array The array to iterate over.
22929 * @returns {*} Returns the minimum value.
22930 * @example
22931 *
22932 * _.min([4, 2, 8, 6]);
22933 * // => 2
22934 *
22935 * _.min([]);
22936 * // => undefined
22937 */
22938 function min(array) {
22939 return (array && array.length)
22940 ? (0,_baseExtremum_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z)(array, _identity_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z, _baseLt_js__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .Z)
22941 : undefined;
22942 }
22943
22944 /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (min);
22945
22946
22947 /***/ }),
22948
22949 /***/ 41291:
22950 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
22951
22952 "use strict";
22953
22954 // EXPORTS
22955 __webpack_require__.d(__webpack_exports__, {
22956 Z: () => (/* binding */ lodash_es_toFinite)
22957 });
22958
22959 ;// CONCATENATED MODULE: ../node_modules/lodash-es/_trimmedEndIndex.js
22960 /** Used to match a single whitespace character. */
22961 var reWhitespace = /\s/;
22962
22963 /**
22964 * Used by `_.trim` and `_.trimEnd` to get the index of the last non-whitespace
22965 * character of `string`.
22966 *
22967 * @private
22968 * @param {string} string The string to inspect.
22969 * @returns {number} Returns the index of the last non-whitespace character.
22970 */
22971 function trimmedEndIndex(string) {
22972 var index = string.length;
22973
22974 while (index-- && reWhitespace.test(string.charAt(index))) {}
22975 return index;
22976 }
22977
22978 /* harmony default export */ const _trimmedEndIndex = (trimmedEndIndex);
22979
22980 ;// CONCATENATED MODULE: ../node_modules/lodash-es/_baseTrim.js
22981
22982
22983 /** Used to match leading whitespace. */
22984 var reTrimStart = /^\s+/;
22985
22986 /**
22987 * The base implementation of `_.trim`.
22988 *
22989 * @private
22990 * @param {string} string The string to trim.
22991 * @returns {string} Returns the trimmed string.
22992 */
22993 function baseTrim(string) {
22994 return string
22995 ? string.slice(0, _trimmedEndIndex(string) + 1).replace(reTrimStart, '')
22996 : string;
22997 }
22998
22999 /* harmony default export */ const _baseTrim = (baseTrim);
23000
23001 // EXTERNAL MODULE: ../node_modules/lodash-es/isObject.js
23002 var isObject = __webpack_require__(60417);
23003 // EXTERNAL MODULE: ../node_modules/lodash-es/isSymbol.js
23004 var isSymbol = __webpack_require__(59660);
23005 ;// CONCATENATED MODULE: ../node_modules/lodash-es/toNumber.js
23006
23007
23008
23009
23010 /** Used as references for various `Number` constants. */
23011 var NAN = 0 / 0;
23012
23013 /** Used to detect bad signed hexadecimal string values. */
23014 var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
23015
23016 /** Used to detect binary string values. */
23017 var reIsBinary = /^0b[01]+$/i;
23018
23019 /** Used to detect octal string values. */
23020 var reIsOctal = /^0o[0-7]+$/i;
23021
23022 /** Built-in method references without a dependency on `root`. */
23023 var freeParseInt = parseInt;
23024
23025 /**
23026 * Converts `value` to a number.
23027 *
23028 * @static
23029 * @memberOf _
23030 * @since 4.0.0
23031 * @category Lang
23032 * @param {*} value The value to process.
23033 * @returns {number} Returns the number.
23034 * @example
23035 *
23036 * _.toNumber(3.2);
23037 * // => 3.2
23038 *
23039 * _.toNumber(Number.MIN_VALUE);
23040 * // => 5e-324
23041 *
23042 * _.toNumber(Infinity);
23043 * // => Infinity
23044 *
23045 * _.toNumber('3.2');
23046 * // => 3.2
23047 */
23048 function toNumber(value) {
23049 if (typeof value == 'number') {
23050 return value;
23051 }
23052 if ((0,isSymbol/* default */.Z)(value)) {
23053 return NAN;
23054 }
23055 if ((0,isObject/* default */.Z)(value)) {
23056 var other = typeof value.valueOf == 'function' ? value.valueOf() : value;
23057 value = (0,isObject/* default */.Z)(other) ? (other + '') : other;
23058 }
23059 if (typeof value != 'string') {
23060 return value === 0 ? value : +value;
23061 }
23062 value = _baseTrim(value);
23063 var isBinary = reIsBinary.test(value);
23064 return (isBinary || reIsOctal.test(value))
23065 ? freeParseInt(value.slice(2), isBinary ? 2 : 8)
23066 : (reIsBadHex.test(value) ? NAN : +value);
23067 }
23068
23069 /* harmony default export */ const lodash_es_toNumber = (toNumber);
23070
23071 ;// CONCATENATED MODULE: ../node_modules/lodash-es/toFinite.js
23072
23073
23074 /** Used as references for various `Number` constants. */
23075 var INFINITY = 1 / 0,
23076 MAX_INTEGER = 1.7976931348623157e+308;
23077
23078 /**
23079 * Converts `value` to a finite number.
23080 *
23081 * @static
23082 * @memberOf _
23083 * @since 4.12.0
23084 * @category Lang
23085 * @param {*} value The value to convert.
23086 * @returns {number} Returns the converted number.
23087 * @example
23088 *
23089 * _.toFinite(3.2);
23090 * // => 3.2
23091 *
23092 * _.toFinite(Number.MIN_VALUE);
23093 * // => 5e-324
23094 *
23095 * _.toFinite(Infinity);
23096 * // => 1.7976931348623157e+308
23097 *
23098 * _.toFinite('3.2');
23099 * // => 3.2
23100 */
23101 function toFinite(value) {
23102 if (!value) {
23103 return value === 0 ? value : 0;
23104 }
23105 value = lodash_es_toNumber(value);
23106 if (value === INFINITY || value === -INFINITY) {
23107 var sign = (value < 0 ? -1 : 1);
23108 return sign * MAX_INTEGER;
23109 }
23110 return value === value ? value : 0;
23111 }
23112
23113 /* harmony default export */ const lodash_es_toFinite = (toFinite);
23114
23115
23116 /***/ }),
23117
23118 /***/ 98670:
23119 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
23120
23121 "use strict";
23122 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
23123 /* harmony export */ Z: () => (__WEBPACK_DEFAULT_EXPORT__)
23124 /* harmony export */ });
23125 /* harmony import */ var _toFinite_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(41291);
23126
23127
23128 /**
23129 * Converts `value` to an integer.
23130 *
23131 * **Note:** This method is loosely based on
23132 * [`ToInteger`](http://www.ecma-international.org/ecma-262/7.0/#sec-tointeger).
23133 *
23134 * @static
23135 * @memberOf _
23136 * @since 4.0.0
23137 * @category Lang
23138 * @param {*} value The value to convert.
23139 * @returns {number} Returns the converted integer.
23140 * @example
23141 *
23142 * _.toInteger(3.2);
23143 * // => 3
23144 *
23145 * _.toInteger(Number.MIN_VALUE);
23146 * // => 0
23147 *
23148 * _.toInteger(Infinity);
23149 * // => 1.7976931348623157e+308
23150 *
23151 * _.toInteger('3.2');
23152 * // => 3
23153 */
23154 function toInteger(value) {
23155 var result = (0,_toFinite_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z)(value),
23156 remainder = result % 1;
23157
23158 return result === result ? (remainder ? result - remainder : result) : 0;
23159 }
23160
23161 /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (toInteger);
23162
23163
23164 /***/ }),
23165
23166 /***/ 27061:
23167 /***/ ((module) => {
23168
23169 // shim for using process in browser
23170 var process = module.exports = {};
23171
23172 // cached from whatever global is present so that test runners that stub it
23173 // don't break things. But we need to wrap it in a try catch in case it is
23174 // wrapped in strict mode code which doesn't define any globals. It's inside a
23175 // function because try/catches deoptimize in certain engines.
23176
23177 var cachedSetTimeout;
23178 var cachedClearTimeout;
23179
23180 function defaultSetTimout() {
23181 throw new Error('setTimeout has not been defined');
23182 }
23183 function defaultClearTimeout () {
23184 throw new Error('clearTimeout has not been defined');
23185 }
23186 (function () {
23187 try {
23188 if (typeof setTimeout === 'function') {
23189 cachedSetTimeout = setTimeout;
23190 } else {
23191 cachedSetTimeout = defaultSetTimout;
23192 }
23193 } catch (e) {
23194 cachedSetTimeout = defaultSetTimout;
23195 }
23196 try {
23197 if (typeof clearTimeout === 'function') {
23198 cachedClearTimeout = clearTimeout;
23199 } else {
23200 cachedClearTimeout = defaultClearTimeout;
23201 }
23202 } catch (e) {
23203 cachedClearTimeout = defaultClearTimeout;
23204 }
23205 } ())
23206 function runTimeout(fun) {
23207 if (cachedSetTimeout === setTimeout) {
23208 //normal enviroments in sane situations
23209 return setTimeout(fun, 0);
23210 }
23211 // if setTimeout wasn't available but was latter defined
23212 if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
23213 cachedSetTimeout = setTimeout;
23214 return setTimeout(fun, 0);
23215 }
23216 try {
23217 // when when somebody has screwed with setTimeout but no I.E. maddness
23218 return cachedSetTimeout(fun, 0);
23219 } catch(e){
23220 try {
23221 // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
23222 return cachedSetTimeout.call(null, fun, 0);
23223 } catch(e){
23224 // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
23225 return cachedSetTimeout.call(this, fun, 0);
23226 }
23227 }
23228
23229
23230 }
23231 function runClearTimeout(marker) {
23232 if (cachedClearTimeout === clearTimeout) {
23233 //normal enviroments in sane situations
23234 return clearTimeout(marker);
23235 }
23236 // if clearTimeout wasn't available but was latter defined
23237 if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
23238 cachedClearTimeout = clearTimeout;
23239 return clearTimeout(marker);
23240 }
23241 try {
23242 // when when somebody has screwed with setTimeout but no I.E. maddness
23243 return cachedClearTimeout(marker);
23244 } catch (e){
23245 try {
23246 // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
23247 return cachedClearTimeout.call(null, marker);
23248 } catch (e){
23249 // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
23250 // Some versions of I.E. have different rules for clearTimeout vs setTimeout
23251 return cachedClearTimeout.call(this, marker);
23252 }
23253 }
23254
23255
23256
23257 }
23258 var queue = [];
23259 var draining = false;
23260 var currentQueue;
23261 var queueIndex = -1;
23262
23263 function cleanUpNextTick() {
23264 if (!draining || !currentQueue) {
23265 return;
23266 }
23267 draining = false;
23268 if (currentQueue.length) {
23269 queue = currentQueue.concat(queue);
23270 } else {
23271 queueIndex = -1;
23272 }
23273 if (queue.length) {
23274 drainQueue();
23275 }
23276 }
23277
23278 function drainQueue() {
23279 if (draining) {
23280 return;
23281 }
23282 var timeout = runTimeout(cleanUpNextTick);
23283 draining = true;
23284
23285 var len = queue.length;
23286 while(len) {
23287 currentQueue = queue;
23288 queue = [];
23289 while (++queueIndex < len) {
23290 if (currentQueue) {
23291 currentQueue[queueIndex].run();
23292 }
23293 }
23294 queueIndex = -1;
23295 len = queue.length;
23296 }
23297 currentQueue = null;
23298 draining = false;
23299 runClearTimeout(timeout);
23300 }
23301
23302 process.nextTick = function (fun) {
23303 var args = new Array(arguments.length - 1);
23304 if (arguments.length > 1) {
23305 for (var i = 1; i < arguments.length; i++) {
23306 args[i - 1] = arguments[i];
23307 }
23308 }
23309 queue.push(new Item(fun, args));
23310 if (queue.length === 1 && !draining) {
23311 runTimeout(drainQueue);
23312 }
23313 };
23314
23315 // v8 likes predictible objects
23316 function Item(fun, array) {
23317 this.fun = fun;
23318 this.array = array;
23319 }
23320 Item.prototype.run = function () {
23321 this.fun.apply(null, this.array);
23322 };
23323 process.title = 'browser';
23324 process.browser = true;
23325 process.env = {};
23326 process.argv = [];
23327 process.version = ''; // empty string to avoid regexp issues
23328 process.versions = {};
23329
23330 function noop() {}
23331
23332 process.on = noop;
23333 process.addListener = noop;
23334 process.once = noop;
23335 process.off = noop;
23336 process.removeListener = noop;
23337 process.removeAllListeners = noop;
23338 process.emit = noop;
23339 process.prependListener = noop;
23340 process.prependOnceListener = noop;
23341
23342 process.listeners = function (name) { return [] }
23343
23344 process.binding = function (name) {
23345 throw new Error('process.binding is not supported');
23346 };
23347
23348 process.cwd = function () { return '/' };
23349 process.chdir = function (dir) {
23350 throw new Error('process.chdir is not supported');
23351 };
23352 process.umask = function() { return 0; };
23353
23354
23355 /***/ }),
23356
23357 /***/ 97770:
23358 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
23359
23360 "use strict";
23361
23362 /*---------------------------------------------------------------------------------------------
23363 * Copyright (c) Microsoft Corporation. All rights reserved.
23364 * Licensed under the MIT License. See License.txt in the project root for license information.
23365 *--------------------------------------------------------------------------------------------*/
23366 Object.defineProperty(exports, "__esModule", ({ value: true }));
23367 exports.CancellationTokenSource = exports.CancellationToken = void 0;
23368 const ral_1 = __webpack_require__(48094);
23369 const Is = __webpack_require__(78472);
23370 const events_1 = __webpack_require__(345);
23371 var CancellationToken;
23372 (function (CancellationToken) {
23373 CancellationToken.None = Object.freeze({
23374 isCancellationRequested: false,
23375 onCancellationRequested: events_1.Event.None
23376 });
23377 CancellationToken.Cancelled = Object.freeze({
23378 isCancellationRequested: true,
23379 onCancellationRequested: events_1.Event.None
23380 });
23381 function is(value) {
23382 const candidate = value;
23383 return candidate && (candidate === CancellationToken.None
23384 || candidate === CancellationToken.Cancelled
23385 || (Is.boolean(candidate.isCancellationRequested) && !!candidate.onCancellationRequested));
23386 }
23387 CancellationToken.is = is;
23388 })(CancellationToken || (exports.CancellationToken = CancellationToken = {}));
23389 const shortcutEvent = Object.freeze(function (callback, context) {
23390 const handle = (0, ral_1.default)().timer.setTimeout(callback.bind(context), 0);
23391 return { dispose() { handle.dispose(); } };
23392 });
23393 class MutableToken {
23394 constructor() {
23395 this._isCancelled = false;
23396 }
23397 cancel() {
23398 if (!this._isCancelled) {
23399 this._isCancelled = true;
23400 if (this._emitter) {
23401 this._emitter.fire(undefined);
23402 this.dispose();
23403 }
23404 }
23405 }
23406 get isCancellationRequested() {
23407 return this._isCancelled;
23408 }
23409 get onCancellationRequested() {
23410 if (this._isCancelled) {
23411 return shortcutEvent;
23412 }
23413 if (!this._emitter) {
23414 this._emitter = new events_1.Emitter();
23415 }
23416 return this._emitter.event;
23417 }
23418 dispose() {
23419 if (this._emitter) {
23420 this._emitter.dispose();
23421 this._emitter = undefined;
23422 }
23423 }
23424 }
23425 class CancellationTokenSource {
23426 get token() {
23427 if (!this._token) {
23428 // be lazy and create the token only when
23429 // actually needed
23430 this._token = new MutableToken();
23431 }
23432 return this._token;
23433 }
23434 cancel() {
23435 if (!this._token) {
23436 // save an object by returning the default
23437 // cancelled token when cancellation happens
23438 // before someone asks for the token
23439 this._token = CancellationToken.Cancelled;
23440 }
23441 else {
23442 this._token.cancel();
23443 }
23444 }
23445 dispose() {
23446 if (!this._token) {
23447 // ensure to initialize with an empty token if we had none
23448 this._token = CancellationToken.None;
23449 }
23450 else if (this._token instanceof MutableToken) {
23451 // actually dispose
23452 this._token.dispose();
23453 }
23454 }
23455 }
23456 exports.CancellationTokenSource = CancellationTokenSource;
23457
23458
23459 /***/ }),
23460
23461 /***/ 345:
23462 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
23463
23464 "use strict";
23465
23466 /* --------------------------------------------------------------------------------------------
23467 * Copyright (c) Microsoft Corporation. All rights reserved.
23468 * Licensed under the MIT License. See License.txt in the project root for license information.
23469 * ------------------------------------------------------------------------------------------ */
23470 Object.defineProperty(exports, "__esModule", ({ value: true }));
23471 exports.Emitter = exports.Event = void 0;
23472 const ral_1 = __webpack_require__(48094);
23473 var Event;
23474 (function (Event) {
23475 const _disposable = { dispose() { } };
23476 Event.None = function () { return _disposable; };
23477 })(Event || (exports.Event = Event = {}));
23478 class CallbackList {
23479 add(callback, context = null, bucket) {
23480 if (!this._callbacks) {
23481 this._callbacks = [];
23482 this._contexts = [];
23483 }
23484 this._callbacks.push(callback);
23485 this._contexts.push(context);
23486 if (Array.isArray(bucket)) {
23487 bucket.push({ dispose: () => this.remove(callback, context) });
23488 }
23489 }
23490 remove(callback, context = null) {
23491 if (!this._callbacks) {
23492 return;
23493 }
23494 let foundCallbackWithDifferentContext = false;
23495 for (let i = 0, len = this._callbacks.length; i < len; i++) {
23496 if (this._callbacks[i] === callback) {
23497 if (this._contexts[i] === context) {
23498 // callback & context match => remove it
23499 this._callbacks.splice(i, 1);
23500 this._contexts.splice(i, 1);
23501 return;
23502 }
23503 else {
23504 foundCallbackWithDifferentContext = true;
23505 }
23506 }
23507 }
23508 if (foundCallbackWithDifferentContext) {
23509 throw new Error('When adding a listener with a context, you should remove it with the same context');
23510 }
23511 }
23512 invoke(...args) {
23513 if (!this._callbacks) {
23514 return [];
23515 }
23516 const ret = [], callbacks = this._callbacks.slice(0), contexts = this._contexts.slice(0);
23517 for (let i = 0, len = callbacks.length; i < len; i++) {
23518 try {
23519 ret.push(callbacks[i].apply(contexts[i], args));
23520 }
23521 catch (e) {
23522 // eslint-disable-next-line no-console
23523 (0, ral_1.default)().console.error(e);
23524 }
23525 }
23526 return ret;
23527 }
23528 isEmpty() {
23529 return !this._callbacks || this._callbacks.length === 0;
23530 }
23531 dispose() {
23532 this._callbacks = undefined;
23533 this._contexts = undefined;
23534 }
23535 }
23536 class Emitter {
23537 constructor(_options) {
23538 this._options = _options;
23539 }
23540 /**
23541 * For the public to allow to subscribe
23542 * to events from this Emitter
23543 */
23544 get event() {
23545 if (!this._event) {
23546 this._event = (listener, thisArgs, disposables) => {
23547 if (!this._callbacks) {
23548 this._callbacks = new CallbackList();
23549 }
23550 if (this._options && this._options.onFirstListenerAdd && this._callbacks.isEmpty()) {
23551 this._options.onFirstListenerAdd(this);
23552 }
23553 this._callbacks.add(listener, thisArgs);
23554 const result = {
23555 dispose: () => {
23556 if (!this._callbacks) {
23557 // disposable is disposed after emitter is disposed.
23558 return;
23559 }
23560 this._callbacks.remove(listener, thisArgs);
23561 result.dispose = Emitter._noop;
23562 if (this._options && this._options.onLastListenerRemove && this._callbacks.isEmpty()) {
23563 this._options.onLastListenerRemove(this);
23564 }
23565 }
23566 };
23567 if (Array.isArray(disposables)) {
23568 disposables.push(result);
23569 }
23570 return result;
23571 };
23572 }
23573 return this._event;
23574 }
23575 /**
23576 * To be kept private to fire an event to
23577 * subscribers
23578 */
23579 fire(event) {
23580 if (this._callbacks) {
23581 this._callbacks.invoke.call(this._callbacks, event);
23582 }
23583 }
23584 dispose() {
23585 if (this._callbacks) {
23586 this._callbacks.dispose();
23587 this._callbacks = undefined;
23588 }
23589 }
23590 }
23591 exports.Emitter = Emitter;
23592 Emitter._noop = function () { };
23593
23594
23595 /***/ }),
23596
23597 /***/ 78472:
23598 /***/ ((__unused_webpack_module, exports) => {
23599
23600 "use strict";
23601
23602 /* --------------------------------------------------------------------------------------------
23603 * Copyright (c) Microsoft Corporation. All rights reserved.
23604 * Licensed under the MIT License. See License.txt in the project root for license information.
23605 * ------------------------------------------------------------------------------------------ */
23606 Object.defineProperty(exports, "__esModule", ({ value: true }));
23607 exports.stringArray = exports.array = exports.func = exports.error = exports.number = exports.string = exports.boolean = void 0;
23608 function boolean(value) {
23609 return value === true || value === false;
23610 }
23611 exports.boolean = boolean;
23612 function string(value) {
23613 return typeof value === 'string' || value instanceof String;
23614 }
23615 exports.string = string;
23616 function number(value) {
23617 return typeof value === 'number' || value instanceof Number;
23618 }
23619 exports.number = number;
23620 function error(value) {
23621 return value instanceof Error;
23622 }
23623 exports.error = error;
23624 function func(value) {
23625 return typeof value === 'function';
23626 }
23627 exports.func = func;
23628 function array(value) {
23629 return Array.isArray(value);
23630 }
23631 exports.array = array;
23632 function stringArray(value) {
23633 return array(value) && value.every(elem => string(elem));
23634 }
23635 exports.stringArray = stringArray;
23636
23637
23638 /***/ }),
23639
23640 /***/ 48094:
23641 /***/ ((__unused_webpack_module, exports) => {
23642
23643 "use strict";
23644
23645 /* --------------------------------------------------------------------------------------------
23646 * Copyright (c) Microsoft Corporation. All rights reserved.
23647 * Licensed under the MIT License. See License.txt in the project root for license information.
23648 * ------------------------------------------------------------------------------------------ */
23649 Object.defineProperty(exports, "__esModule", ({ value: true }));
23650 let _ral;
23651 function RAL() {
23652 if (_ral === undefined) {
23653 throw new Error(`No runtime abstraction layer installed`);
23654 }
23655 return _ral;
23656 }
23657 (function (RAL) {
23658 function install(ral) {
23659 if (ral === undefined) {
23660 throw new Error(`No runtime abstraction layer provided`);
23661 }
23662 _ral = ral;
23663 }
23664 RAL.install = install;
23665 })(RAL || (RAL = {}));
23666 exports["default"] = RAL;
23667
23668
23669 /***/ }),
23670
23671 /***/ 37943:
23672 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
23673
23674 "use strict";
23675 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
23676 /* harmony export */ c: () => (/* binding */ Utils),
23677 /* harmony export */ o: () => (/* binding */ URI)
23678 /* harmony export */ });
23679 /* provided dependency */ var process = __webpack_require__(27061);
23680 var LIB;(()=>{"use strict";var t={470:t=>{function e(t){if("string"!=typeof t)throw new TypeError("Path must be a string. Received "+JSON.stringify(t))}function r(t,e){for(var r,n="",i=0,o=-1,s=0,h=0;h<=t.length;++h){if(h<t.length)r=t.charCodeAt(h);else{if(47===r)break;r=47}if(47===r){if(o===h-1||1===s);else if(o!==h-1&&2===s){if(n.length<2||2!==i||46!==n.charCodeAt(n.length-1)||46!==n.charCodeAt(n.length-2))if(n.length>2){var a=n.lastIndexOf("/");if(a!==n.length-1){-1===a?(n="",i=0):i=(n=n.slice(0,a)).length-1-n.lastIndexOf("/"),o=h,s=0;continue}}else if(2===n.length||1===n.length){n="",i=0,o=h,s=0;continue}e&&(n.length>0?n+="/..":n="..",i=2)}else n.length>0?n+="/"+t.slice(o+1,h):n=t.slice(o+1,h),i=h-o-1;o=h,s=0}else 46===r&&-1!==s?++s:s=-1}return n}var n={resolve:function(){for(var t,n="",i=!1,o=arguments.length-1;o>=-1&&!i;o--){var s;o>=0?s=arguments[o]:(void 0===t&&(t=process.cwd()),s=t),e(s),0!==s.length&&(n=s+"/"+n,i=47===s.charCodeAt(0))}return n=r(n,!i),i?n.length>0?"/"+n:"/":n.length>0?n:"."},normalize:function(t){if(e(t),0===t.length)return".";var n=47===t.charCodeAt(0),i=47===t.charCodeAt(t.length-1);return 0!==(t=r(t,!n)).length||n||(t="."),t.length>0&&i&&(t+="/"),n?"/"+t:t},isAbsolute:function(t){return e(t),t.length>0&&47===t.charCodeAt(0)},join:function(){if(0===arguments.length)return".";for(var t,r=0;r<arguments.length;++r){var i=arguments[r];e(i),i.length>0&&(void 0===t?t=i:t+="/"+i)}return void 0===t?".":n.normalize(t)},relative:function(t,r){if(e(t),e(r),t===r)return"";if((t=n.resolve(t))===(r=n.resolve(r)))return"";for(var i=1;i<t.length&&47===t.charCodeAt(i);++i);for(var o=t.length,s=o-i,h=1;h<r.length&&47===r.charCodeAt(h);++h);for(var a=r.length-h,c=s<a?s:a,f=-1,u=0;u<=c;++u){if(u===c){if(a>c){if(47===r.charCodeAt(h+u))return r.slice(h+u+1);if(0===u)return r.slice(h+u)}else s>c&&(47===t.charCodeAt(i+u)?f=u:0===u&&(f=0));break}var l=t.charCodeAt(i+u);if(l!==r.charCodeAt(h+u))break;47===l&&(f=u)}var g="";for(u=i+f+1;u<=o;++u)u!==o&&47!==t.charCodeAt(u)||(0===g.length?g+="..":g+="/..");return g.length>0?g+r.slice(h+f):(h+=f,47===r.charCodeAt(h)&&++h,r.slice(h))},_makeLong:function(t){return t},dirname:function(t){if(e(t),0===t.length)return".";for(var r=t.charCodeAt(0),n=47===r,i=-1,o=!0,s=t.length-1;s>=1;--s)if(47===(r=t.charCodeAt(s))){if(!o){i=s;break}}else o=!1;return-1===i?n?"/":".":n&&1===i?"//":t.slice(0,i)},basename:function(t,r){if(void 0!==r&&"string"!=typeof r)throw new TypeError('"ext" argument must be a string');e(t);var n,i=0,o=-1,s=!0;if(void 0!==r&&r.length>0&&r.length<=t.length){if(r.length===t.length&&r===t)return"";var h=r.length-1,a=-1;for(n=t.length-1;n>=0;--n){var c=t.charCodeAt(n);if(47===c){if(!s){i=n+1;break}}else-1===a&&(s=!1,a=n+1),h>=0&&(c===r.charCodeAt(h)?-1==--h&&(o=n):(h=-1,o=a))}return i===o?o=a:-1===o&&(o=t.length),t.slice(i,o)}for(n=t.length-1;n>=0;--n)if(47===t.charCodeAt(n)){if(!s){i=n+1;break}}else-1===o&&(s=!1,o=n+1);return-1===o?"":t.slice(i,o)},extname:function(t){e(t);for(var r=-1,n=0,i=-1,o=!0,s=0,h=t.length-1;h>=0;--h){var a=t.charCodeAt(h);if(47!==a)-1===i&&(o=!1,i=h+1),46===a?-1===r?r=h:1!==s&&(s=1):-1!==r&&(s=-1);else if(!o){n=h+1;break}}return-1===r||-1===i||0===s||1===s&&r===i-1&&r===n+1?"":t.slice(r,i)},format:function(t){if(null===t||"object"!=typeof t)throw new TypeError('The "pathObject" argument must be of type Object. Received type '+typeof t);return function(t,e){var r=e.dir||e.root,n=e.base||(e.name||"")+(e.ext||"");return r?r===e.root?r+n:r+"/"+n:n}(0,t)},parse:function(t){e(t);var r={root:"",dir:"",base:"",ext:"",name:""};if(0===t.length)return r;var n,i=t.charCodeAt(0),o=47===i;o?(r.root="/",n=1):n=0;for(var s=-1,h=0,a=-1,c=!0,f=t.length-1,u=0;f>=n;--f)if(47!==(i=t.charCodeAt(f)))-1===a&&(c=!1,a=f+1),46===i?-1===s?s=f:1!==u&&(u=1):-1!==s&&(u=-1);else if(!c){h=f+1;break}return-1===s||-1===a||0===u||1===u&&s===a-1&&s===h+1?-1!==a&&(r.base=r.name=0===h&&o?t.slice(1,a):t.slice(h,a)):(0===h&&o?(r.name=t.slice(1,s),r.base=t.slice(1,a)):(r.name=t.slice(h,s),r.base=t.slice(h,a)),r.ext=t.slice(s,a)),h>0?r.dir=t.slice(0,h-1):o&&(r.dir="/"),r},sep:"/",delimiter:":",win32:null,posix:null};n.posix=n,t.exports=n}},e={};function r(n){var i=e[n];if(void 0!==i)return i.exports;var o=e[n]={exports:{}};return t[n](o,o.exports,r),o.exports}r.d=(t,e)=>{for(var n in e)r.o(e,n)&&!r.o(t,n)&&Object.defineProperty(t,n,{enumerable:!0,get:e[n]})},r.o=(t,e)=>Object.prototype.hasOwnProperty.call(t,e),r.r=t=>{"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(t,"__esModule",{value:!0})};var n={};(()=>{let t;if(r.r(n),r.d(n,{URI:()=>f,Utils:()=>P}),"object"==typeof process)t="win32"===process.platform;else if("object"==typeof navigator){let e=navigator.userAgent;t=e.indexOf("Windows")>=0}const e=/^\w[\w\d+.-]*$/,i=/^\//,o=/^\/\//;function s(t,r){if(!t.scheme&&r)throw new Error(`[UriError]: Scheme is missing: {scheme: "", authority: "${t.authority}", path: "${t.path}", query: "${t.query}", fragment: "${t.fragment}"}`);if(t.scheme&&!e.test(t.scheme))throw new Error("[UriError]: Scheme contains illegal characters.");if(t.path)if(t.authority){if(!i.test(t.path))throw new Error('[UriError]: If a URI contains an authority component, then the path component must either be empty or begin with a slash ("/") character')}else if(o.test(t.path))throw new Error('[UriError]: If a URI does not contain an authority component, then the path cannot begin with two slash characters ("//")')}const h="",a="/",c=/^(([^:/?#]+?):)?(\/\/([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?/;class f{static isUri(t){return t instanceof f||!!t&&"string"==typeof t.authority&&"string"==typeof t.fragment&&"string"==typeof t.path&&"string"==typeof t.query&&"string"==typeof t.scheme&&"string"==typeof t.fsPath&&"function"==typeof t.with&&"function"==typeof t.toString}scheme;authority;path;query;fragment;constructor(t,e,r,n,i,o=!1){"object"==typeof t?(this.scheme=t.scheme||h,this.authority=t.authority||h,this.path=t.path||h,this.query=t.query||h,this.fragment=t.fragment||h):(this.scheme=function(t,e){return t||e?t:"file"}(t,o),this.authority=e||h,this.path=function(t,e){switch(t){case"https":case"http":case"file":e?e[0]!==a&&(e=a+e):e=a}return e}(this.scheme,r||h),this.query=n||h,this.fragment=i||h,s(this,o))}get fsPath(){return m(this,!1)}with(t){if(!t)return this;let{scheme:e,authority:r,path:n,query:i,fragment:o}=t;return void 0===e?e=this.scheme:null===e&&(e=h),void 0===r?r=this.authority:null===r&&(r=h),void 0===n?n=this.path:null===n&&(n=h),void 0===i?i=this.query:null===i&&(i=h),void 0===o?o=this.fragment:null===o&&(o=h),e===this.scheme&&r===this.authority&&n===this.path&&i===this.query&&o===this.fragment?this:new l(e,r,n,i,o)}static parse(t,e=!1){const r=c.exec(t);return r?new l(r[2]||h,C(r[4]||h),C(r[5]||h),C(r[7]||h),C(r[9]||h),e):new l(h,h,h,h,h)}static file(e){let r=h;if(t&&(e=e.replace(/\\/g,a)),e[0]===a&&e[1]===a){const t=e.indexOf(a,2);-1===t?(r=e.substring(2),e=a):(r=e.substring(2,t),e=e.substring(t)||a)}return new l("file",r,e,h,h)}static from(t){const e=new l(t.scheme,t.authority,t.path,t.query,t.fragment);return s(e,!0),e}toString(t=!1){return y(this,t)}toJSON(){return this}static revive(t){if(t){if(t instanceof f)return t;{const e=new l(t);return e._formatted=t.external,e._fsPath=t._sep===u?t.fsPath:null,e}}return t}}const u=t?1:void 0;class l extends f{_formatted=null;_fsPath=null;get fsPath(){return this._fsPath||(this._fsPath=m(this,!1)),this._fsPath}toString(t=!1){return t?y(this,!0):(this._formatted||(this._formatted=y(this,!1)),this._formatted)}toJSON(){const t={$mid:1};return this._fsPath&&(t.fsPath=this._fsPath,t._sep=u),this._formatted&&(t.external=this._formatted),this.path&&(t.path=this.path),this.scheme&&(t.scheme=this.scheme),this.authority&&(t.authority=this.authority),this.query&&(t.query=this.query),this.fragment&&(t.fragment=this.fragment),t}}const g={58:"%3A",47:"%2F",63:"%3F",35:"%23",91:"%5B",93:"%5D",64:"%40",33:"%21",36:"%24",38:"%26",39:"%27",40:"%28",41:"%29",42:"%2A",43:"%2B",44:"%2C",59:"%3B",61:"%3D",32:"%20"};function d(t,e,r){let n,i=-1;for(let o=0;o<t.length;o++){const s=t.charCodeAt(o);if(s>=97&&s<=122||s>=65&&s<=90||s>=48&&s<=57||45===s||46===s||95===s||126===s||e&&47===s||r&&91===s||r&&93===s||r&&58===s)-1!==i&&(n+=encodeURIComponent(t.substring(i,o)),i=-1),void 0!==n&&(n+=t.charAt(o));else{void 0===n&&(n=t.substr(0,o));const e=g[s];void 0!==e?(-1!==i&&(n+=encodeURIComponent(t.substring(i,o)),i=-1),n+=e):-1===i&&(i=o)}}return-1!==i&&(n+=encodeURIComponent(t.substring(i))),void 0!==n?n:t}function p(t){let e;for(let r=0;r<t.length;r++){const n=t.charCodeAt(r);35===n||63===n?(void 0===e&&(e=t.substr(0,r)),e+=g[n]):void 0!==e&&(e+=t[r])}return void 0!==e?e:t}function m(e,r){let n;return n=e.authority&&e.path.length>1&&"file"===e.scheme?`//${e.authority}${e.path}`:47===e.path.charCodeAt(0)&&(e.path.charCodeAt(1)>=65&&e.path.charCodeAt(1)<=90||e.path.charCodeAt(1)>=97&&e.path.charCodeAt(1)<=122)&&58===e.path.charCodeAt(2)?r?e.path.substr(1):e.path[1].toLowerCase()+e.path.substr(2):e.path,t&&(n=n.replace(/\//g,"\\")),n}function y(t,e){const r=e?p:d;let n="",{scheme:i,authority:o,path:s,query:h,fragment:c}=t;if(i&&(n+=i,n+=":"),(o||"file"===i)&&(n+=a,n+=a),o){let t=o.indexOf("@");if(-1!==t){const e=o.substr(0,t);o=o.substr(t+1),t=e.lastIndexOf(":"),-1===t?n+=r(e,!1,!1):(n+=r(e.substr(0,t),!1,!1),n+=":",n+=r(e.substr(t+1),!1,!0)),n+="@"}o=o.toLowerCase(),t=o.lastIndexOf(":"),-1===t?n+=r(o,!1,!0):(n+=r(o.substr(0,t),!1,!0),n+=o.substr(t))}if(s){if(s.length>=3&&47===s.charCodeAt(0)&&58===s.charCodeAt(2)){const t=s.charCodeAt(1);t>=65&&t<=90&&(s=`/${String.fromCharCode(t+32)}:${s.substr(3)}`)}else if(s.length>=2&&58===s.charCodeAt(1)){const t=s.charCodeAt(0);t>=65&&t<=90&&(s=`${String.fromCharCode(t+32)}:${s.substr(2)}`)}n+=r(s,!0,!1)}return h&&(n+="?",n+=r(h,!1,!1)),c&&(n+="#",n+=e?c:d(c,!1,!1)),n}function v(t){try{return decodeURIComponent(t)}catch{return t.length>3?t.substr(0,3)+v(t.substr(3)):t}}const b=/(%[0-9A-Za-z][0-9A-Za-z])+/g;function C(t){return t.match(b)?t.replace(b,(t=>v(t))):t}var A=r(470);const w=A.posix||A,x="/";var P;!function(t){t.joinPath=function(t,...e){return t.with({path:w.join(t.path,...e)})},t.resolvePath=function(t,...e){let r=t.path,n=!1;r[0]!==x&&(r=x+r,n=!0);let i=w.resolve(r,...e);return n&&i[0]===x&&!t.authority&&(i=i.substring(1)),t.with({path:i})},t.dirname=function(t){if(0===t.path.length||t.path===x)return t;let e=w.dirname(t.path);return 1===e.length&&46===e.charCodeAt(0)&&(e=""),t.with({path:e})},t.basename=function(t){return w.basename(t.path)},t.extname=function(t){return w.extname(t.path)}}(P||(P={}))})(),LIB=n})();const{URI,Utils}=LIB;
23681 //# sourceMappingURL=index.mjs.map
23682
23683 /***/ })
23684
23685 }]);
23686 //# sourceMappingURL=3197.c29a6f351f8c45adc2c5.js.map?v=c29a6f351f8c45adc2c5